.net - una - formato dll

Cuando los dlls de lanzamiento no funcionan, pero los dlls de depuración hacen

Question

Después de implementar nuestro enorme sistema distribuido a uno de nuestros clientes, experimentamos un error inesperado. Durante la investigación, reemplazamos el conjunto causando el error con uno en el que hemos agregado algún código de diagnóstico. El dll que usamos está construido en modo de depuración. ¡Y de repente todo funciona!

Reemplazar el dll de depuración con la versión de lanzamiento (con el código de diagnóstico) lo hace colapsar nuevamente.

No hay directivas de precompiladores, atributos de depuración condicional, etc. en nuestro código. El problema se ha encontrado en dos sitios de instalación diferentes, mientras que funciona bien en varios más.

(El proyecto tiene una mezcla de C # y VB.NET, el ensamblaje de problemas es VB.NET ..., si eso hace alguna diferencia)

Entonces la pregunta es: ¿qué haces en situaciones como esta? ¿Y cuál puede ser la causa, en general? Cualquier consejo sobre la depuración de este problema es bienvenido.

Answer 1

Puede probar y desactivar Optimize Code en Build Settings. ¿Cuál es el error real que está recibiendo?

Otra cosa que puedes hacer es compilar en modo de lanzamiento, pero habilita el #Debug condicional. Esto manejará el caso si usa Diagnostics.Debug y el código afecta su aplicación.

Answer 2

Por causas ... bueno, algún indicio del síntoma sería útil. Una posibilidad es que tenga código para un método como Debug.WriteLine que tiene efectos secundarios (es decir, lo hace funcionar). Las llamadas a los métodos marcados con [Conditional(...)] no se compilan a menos que tenga los símbolos correctos definidos, por lo que cualquier elemento marcado [Conditional("DEBUG")] se eliminará en silencio.

También podría ser un error del compilador, pero eso es un poco improbable (pero no imposible).

¿Cuál es el síntoma? ¿Cómo se rompe?

Como un ejemplo de lo anterior:

    static string Bar { get; set; }
    static void Main()
    {
        Bar = "I''m broken";
        Debug.WriteLine(Foo());
        Console.WriteLine(Bar);
    }
    // note Foo only called in DEBUG builds
    static string Foo()
    {
        Bar = "I''m working";
        return "mwahahah";
    }

Compilado en modo DEBUG imprime "Estoy trabajando"; compilado en modo RELEASE, imprime "Estoy roto". ¿Suena similar? Compruebe que no está llamando a ningún método de depuración directamente con cosas que tienen efectos secundarios. En la mayoría de los casos, puede solucionarlo por indirección:

string foo = Foo();
Debug.WriteLine(foo);

Ahora se llama en cualquier modo.

Answer 3

¿Has intentado incluir los archivos de depuración? (los pdbs)

Si accedes a la configuración de tu proyecto y luego compilas, selecciona la versión de lanzamiento en el menú desplegable cerca de la parte superior, luego elige opciones avanzadas de compilación cerca de la parte inferior, asegúrate de configurarlo para crear información completa de depuración y luego volver a desplegarlo. ahora obtenga información más detallada sobre el motivo del bloqueo.

Answer 4

He visto un momento que causa problemas entre la creación de Debug y Release. En general, la compilación de depuración se ejecuta más lentamente que la versión de lanzamiento. Es posible que desee verificar la sección de tiempo crítico de su código.

Answer 5

Puede ser una especie de condición de carrera que tengas, si no estás trabajando en un código de un solo subproceso. Por ejemplo, si alguna parte de su programa necesita realizar algunas acciones antes de que otras partes puedan acceder a ella, puede fallar en el modo de lanzamiento simplemente porque el código se accede demasiado pronto. Una vez tuvimos un problema similar con un código para teléfonos móviles que funcionaba bien en el emulador, pero en el teléfono, que era más lento, la situación no era la misma.

Answer 6

Probablemente sepa esto, pero las variables a veces se inicializan de forma diferente en versiones de depuración y liberación. Por ejemplo, creo que las variables se inician automáticamente en compilaciones de depuración de VC6, esto puede ocultar problemas si no se inicializa algo. También creo que las matrices de depuración pueden usar bytes centinela en un intento de indicar sobrepasos. Esto también puede conducir a un comportamiento diferente.

Answer 7

Tuve un problema en un punto con los finalizadores que se activaron antes de lo esperado, porque no entendía completamente la interacción entre los finalizadores, el recolector de basura y cuando un objeto local se considera coleccionable (pista: no está en la llave de cierre de el bloque). Si su código usa finalizadores, puede consultar GC.KeepAlive (). En el siguiente bloque:

void MyFunction() 
{ 
  Foo f = new Foo();
  SomeFunction(f.SomeProp);
}

f vuelve elegible para la finalización antes de que SomeFunction() ejecute. Si el finalizador hace algo como deshacerse de lo que SomeProp , podría tener problemas. Agregar una llamada a GC.KeepAlive(f) después de la llamada a SomeFunction garantiza que f no sea elegible para la finalización hasta después de la llamada a KeepAlive() .

Editar: después de todo eso, me olvidé de señalar que este problema era mucho más pronunciado cuando se ejecutaba en modo de lanzamiento. No sé si la compilación Debug pone KeepAlives implícitos para los locales al final de la función para el beneficio del depurador, o si la recolección de basura es simplemente menos agresiva, o qué, pero el modo Liberar exacerbó este problema en gran medida en mi caso.

Answer 8

¿Has resuelto tu problema?
Estoy teniendo el mismo problema que tú.
Si compilo el dll en la depuración, todo funciona bien.
Si compilo en el lanzamiento obtengo una excepción de referencia nula.
Pero si incluyo algunas líneas como la anterior en algunos métodos, la excepción desaparece incluso en el modo de lanzamiento:
System.Diagnostics.EventLog.WriteEntry ("blablabla", "blablabla")

Espero que te ayude

Answer 9

Tuve un problema similar. Mi situación como esta: definí algunas funciones de reflexión en una biblioteca de clase A. Luego definí una biblioteca de control de usuario WPF B, que usa las funciones de la biblioteca A. Luego codifiqué una aplicación que usa el control de usuario de la biblioteca B y funciones en biblioteca A. Cuando utilicé la versión de depuración de la biblioteca B, funciona bien. Pero cuando utilicé la versión de lanzamiento de la biblioteca B, las funciones de reflexión no funcionaron. También definí otras funciones en la biblioteca A. Parece que solo las funciones de reflexión están causando problemas. No puedo entender la razón. Finalmente, abandoné y moví las funciones de reflexión de la biblioteca A a la biblioteca B. Y funcionó.

Answer 10

Debug.Assert(ImportantMethod());

Answer 11

Asegúrese de que la Aplicación esté compilando bajo el Objetivo de Plataforma correcto. Esto puede ser un problema, especialmente cuando se trata de proporcionar o consumir archivos DLL. Busque en "Proyecto-> Propiedades" y seleccione la pestaña "Generar". La opción de destino de la plataforma le permitirá seleccionar entre Cualquier CPU (predeterminado), x86 o x64.

Answer 12

Antes que nada, lo siento por mi inglés. Sé que esta publicación es antigua pero tengo el mismo problema, y ​​me doy cuenta de que en el modo de depuración la compilación está hecha para sistemas operativos de 32 bits , y el modo de lanzamiento es de 64 bits de manera predeterminada. Esto hace que el dll para 32 bits no funcione en la versión. Si va a Propiedades del proyecto -> compilación, puede elegir la arquitectura que desee. Esto funciona para mí Adiós.

Answer 13

En mi caso, fue que mi proyecto de consumo de DLL (en VS) tenía configuración x64, pero la solución estaba en cualquier CPU. Por algún motivo, al ejecutar la aplicación, esto no se enganchó con mi DLL x64. Configuré la aplicación a una plataforma x64 explícitamente y todo funcionó correctamente.