Ao longo de 2025, o equipo de PVS-Studio está a comprobar activamente os proxectos de C# de código aberto. Ao longo do ano, descubrimos unha morea de defectos. Entón, seleccionamos os dez máis interesantes desta enorme variedade. Esperamos que este roundup sexa interesante e útil. Como fixemos o top? Hai varios criterios que o código do proxecto debe cumprir para gañar un lugar na nosa lista de arriba: 
 
 
 
 
 
 procede dun proxecto de código aberto; os problemas foron detectados por PVS-Studio; o código máis probablemente conteña erros; o código é interesante para comprobar; Cada erro é único. Xa que regularmente compilamos tales listas, reunimos unha impresionante colección de erros curiosos. 
 
 
 
 
 
 
 Os 10 erros máis comúns en 2024 Os 10 erros máis comúns en 2023 Os 10 erros máis comúns en 2022 ; top 10 errors in 2021 Os 10 mellores erros de 2020 ; top 10 errors in 2019 Agora, imos mergullarnos no fascinante abismo de erros C# para 2025! P.S. O autor do artigo seleccionou e agrupou os erros en base á súa opinión subxectiva.Se pensas que este ou aquel bug merece outro lugar, non deixes de deixar un comentario :) Terceiro lugar: Probe atopalo O día de hoxe comeza cun erro mencionado na Parece que .NET 9 acaba de ser lanzado, pero hai un pouco máis dun mes, .NET 10 substituíuno. . Páxinas que ligan con .NET 9 Este artigo Volvamos á análise: public static void SetAsIConvertible(this ref ComVariant variant,
                                     IConvertible value)
{
  TypeCode tc = value.GetTypeCode();
  CultureInfo ci = CultureInfo.CurrentCulture;

  switch (tc)
  {
    case TypeCode.Empty: break;
    case TypeCode.Object: 
      variant = ComVariant.CreateRaw(....); break;
    case TypeCode.DBNull: 
      variant = ComVariant.Null; break;
    case TypeCode.Boolean: 
      variant = ComVariant.Create<bool>(....)); break;
    case TypeCode.Char: 
      variant = ComVariant.Create<ushort>(value.ToChar(ci)); break;
    case TypeCode.SByte: 
      variant = ComVariant.Create<sbyte>(value.ToSByte(ci)); break;
    case TypeCode.Byte: 
      variant = ComVariant.Create<byte>(value.ToByte(ci)); break;
    case TypeCode.Int16: 
      variant = ComVariant.Create(value.ToInt16(ci)); break;
    case TypeCode.UInt16: 
      variant = ComVariant.Create(value.ToUInt16(ci)); break;
    case TypeCode.Int32: 
      variant = ComVariant.Create(value.ToInt32(ci)); break;
    case TypeCode.UInt32: 
      variant = ComVariant.Create(value.ToUInt32(ci)); break;
    case TypeCode.Int64: 
      variant = ComVariant.Create(value.ToInt64(ci)); break;
    case TypeCode.UInt64: 
      variant = ComVariant.Create(value.ToInt64(ci)); break;
    case TypeCode.Single: 
      variant = ComVariant.Create(value.ToSingle(ci)); break;
    case TypeCode.Double: 
      variant = ComVariant.Create(value.ToDouble(ci)); break;
    case TypeCode.Decimal: 
      variant = ComVariant.Create(value.ToDecimal(ci)); break;
    case TypeCode.DateTime: 
      variant = ComVariant.Create(value.ToDateTime(ci)); break;
    case TypeCode.String: 
      variant = ComVariant.Create(....); break;

    default:
      throw new NotSupportedException();
  }
}
 Entrar en modo pantalla completa Saír en modo pantalla completa Podes ver o problema?É definitivamente alí! case TypeCode.Int64: 
  variant = ComVariant.Create(value.ToInt64(ci)); break;
case TypeCode.UInt64: 
  variant = ComVariant.Create(value.ToInt64(ci)); break; // <=
 Entrar en modo pantalla completa Saír en modo pantalla completa PVS-Studio advertencia de: Dous ou máis casos realizan as mesmas accións. DynamicVariantExtensions.cs 68 Páxina 3139 Espero que teñas dado aos teus ollos un bo adestramento, e a túa vista aguda non te deixou caer. No canto de os desenvolvedores deberían ter utilizado os Isto pode ser un erro de copia-paste. case TypeCode.UInt64 value.ToInt64 ToUInt64() 9o lugar. formato non válido O noveno lugar vai a un erro descrito na : artigo sobre a comprobación dos proxectos Neo e NBitcoin public override string ToString()
{
  var sb = new StringBuilder();

  sb.AppendFormat("{1:X04} {2,-10}{3}{4}", 
                  Position, 
                  OpCode, 
                  DecodeOperand());

  return sb.ToString();
}
 Entrar en modo pantalla completa Saír en modo pantalla completa PVS-Studio advertencia de: [CWE-685] Formato incorrecto. Espérase un número diferente de elementos de formato ao chamar a función 'AppendFormat'. Elementos de formato non utilizados: {3}, {4}. Argumentos non utilizados: 1o VMInstruction.cs 105 Páxina 3025 Chamando á sobriedade O resultado é unha excepción, debido a unha incorrección. Unha chamada que contén dous erros. ToString sb.AppendFormat 
 
 
 O número de argumentos a inserir é menor que o número de lugares na cadea de formato, o que provoca a excepción. Aínda que corrixamos o primeiro problema ao coincidir o número de argumentos e detentores de lugar, a chamada aínda botará a excepción. Isto é porque a indexación do detentor de lugar comeza con 0, non 1. Oitavo lugar: Navel-gazing O seguinte erro vén da : Artigo sobre a proba do motor de negociación Lean public override int GetHashCode()
{
  unchecked
  {
    var hashCode = Definition.GetHashCode();
    var arr = new int[Legs.Count];
    for (int i = 0; i < Legs.Count; i++)
    {
      arr[i] = Legs[i].GetHashCode();
    }

    Array.Sort(arr);

    for (int i = 0; i < arr.Length; i++)
    {
      hashCode = (hashCode * 397) ^ arr[i];
    }

    return hashCode;
  }
}

public override bool Equals(object obj)
{
    ....

    return Equals((OptionStrategyDefinitionMatch) obj);
}
 Entrar en modo pantalla completa Saír en modo pantalla completa PVS-Studio advertencia de: A propiedade 'Legs' utilízase no método 'GetHashCode', pero falta no método 'Equals'. OptionStrategyDefinitionMatch.cs 176 Páxina 3192 O analista fixo unha Comproba na sistema, o que se chama unha superposición e descubriu que non usaba o propiedade, aínda que Confía neles interprocedural Equals Equals Legs GetHashCode Botemos unha ollada máis atenta ao  method: Equals public bool Equals(OptionStrategyDefinitionMatch other)
{
  ....

  var positions = other.Legs
                       .ToDictionary(leg => leg.Position, 
                                     leg => leg.Multiplier);
  foreach (var leg in other.Legs)                                   // <=
  {
    int multiplier;
    if (!positions.TryGetValue(leg.Position, out multiplier))
    {
      return false;
    }

    if (leg.Multiplier != multiplier)
    {
      return false;
    }
  }

  return true;
}
 Entrar en modo pantalla completa Saír en modo pantalla completa Ten en conta que o método itera sobre Para cada elemento da colección, o código intenta atopalo na  dictionary—but that dictionary also comes from  Como resultado, o código verifica se existen elementos dunha colección na mesma colección. other.Legs positions other.Legs Podemos corrixir o código substituíndo con na localización marcada. other.Legs Legs Terceiro lugar: Tricky Equals O sétimo lugar vai a un erro dun : Páxinas que ligan con ScottPlot public class CoordinateRangeMutable : IEquatable<CoordinateRangeMutable>
{
  ....
  public bool Equals(CoordinateRangeMutable? other)
  {
    if (other is null)
      return false;

    return Equals(Min, other.Min) && Equals(Min, other.Min);  // <=
  }

  public override bool Equals(object? obj)
  {
    if (obj is null)
      return false;

    if (obj is CoordinateRangeMutable other)
      return Equals(other);

    return false;
  }

  public override int GetHashCode()
  {
    return Min.GetHashCode() ^ Max.GetHashCode();             // <=
  }
}
 Entrar en modo pantalla completa Saír en modo pantalla completa PVS-Studio advertencias A propiedade 'Max' utilízase no método 'GetHashCode', pero falta no método 'Equals'. Páxina 3192 Existen subexpresións idénticas 'Equals(Min, other.Min)' á esquerda e á dereita do operador '&&'. Páxina 3001 O analista emitiu dúas advertencias para este fragmento de código. Comezaremos coa O analista advirte de que o A propiedade utilízase na  method but not in the  Método: se miramos ao exceso Aínda así, podemos ver que o outro  is called in its body. There we can see the following:  Os  diagnostic rule highlighted this fragment. Páxina 3192 Max GetHashCode Equals Equals Equals Equals(Min, other.Min) && Equals(Min, other.Min) Páxina 3001 Evidentemente, unha das Os operarios deben ter A súa forma. && Equals(Max, other.Max) Entón o analista ten razón - Non aparece na O método. Max Equals 6o lugar.Bit Tricks Un erro que, como o anterior, é tomado da Para rematar, a primeira metade da primeira parte: article on checking ScottPlot public static Interactivity.Key GetKey(this Keys keys)
{

  Keys keyCode = keys & ~Keys.Modifiers;                   // <=
  Interactivity.Key key = keyCode switch
  {
    Keys.Alt => Interactivity.StandardKeys.Alt,            // <=
    Keys.Menu => Interactivity.StandardKeys.Alt,
    Keys.Shift => Interactivity.StandardKeys.Shift,        // <=
    Keys.ShiftKey => Interactivity.StandardKeys.Shift,
    Keys.LShiftKey => Interactivity.StandardKeys.Shift,
    Keys.RShiftKey => Interactivity.StandardKeys.Shift,
    Keys.Control => Interactivity.StandardKeys.Control,    // <=
    Keys.ControlKey => Interactivity.StandardKeys.Control,
    Keys.Down => Interactivity.StandardKeys.Down,
    Keys.Up => Interactivity.StandardKeys.Up,
    Keys.Left => Interactivity.StandardKeys.Left,
    Keys.Right => Interactivity.StandardKeys.Right,
    _ => Interactivity.StandardKeys.Unknown,
  };

  ....
}
 Enter fullscreen mode Exit fullscreen mode PVS-Studio advertencia de: Detectouse un código inaccesible. O valor do 'caso' está fóra do alcance da expresión de encontro. ScottPlot.WinForms FormsPlotExtensions.cs 106 V3202 Valores de patróns múltiples dentro Non é posible na actualidade, imos ver o que está a suceder. switch En primeiro lugar, debemos mirar os valores que corresponden aos elementos erróneos da enumeración. [Flags]
[TypeConverter(typeof(KeysConverter))]
[Editor(....)]
public enum Keys
{
  /// <summary>
  ///  The bit mask to extract modifiers from a key value.
  /// </summary>
  Modifiers = unchecked((int)0xFFFF0000),

  ....
  /// <summary>
  ///  The SHIFT modifier key.
  /// </summary>
  Shift = 0x00010000,

  /// <summary>
  ///  The  CTRL modifier key.
  /// </summary>
  Control = 0x00020000,

  /// <summary>
  ///  The ALT modifier key.
  /// </summary>
  Alt = 0x00040000
}
 Entrar en modo pantalla completa Saír en modo pantalla completa A continuación, imos convertelo en binario: Xa está claro que inclúe cada un dos elementos de enumeración erróneos. Modifiers O valor pasou a  is obtained from the  expresión.Esta expresión exclúe a Valor de Ademais de Con todo, , , and  Tamén será excluído, xa que  already include these values (  have a non-zero bit for each non-zero bit of the erroneous enumeration elements). switch keys & ~Keys.Modifiers Keys.Modifiers keys Keys.Modifiers Shift Control Alt Modifiers Modifiers De todo isto podemos concluír que a combinación de bits que produce , , or  Para o A operación non existe. Shift Control Alt keys & ~Keys.Modifiers O problema pode estar na aplicación en vez de os valores de enumeración. switch 5o Lugar: Todos os xogos O top cinco comeza cun erro mencionado nun : Páxinas que ligan con .NET 9 struct StackValue
{
  ....
  public override bool Equals(object obj)
  {
    if (Object.ReferenceEquals(this, obj))
      return true;

    if (!(obj is StackValue))
      return false;

    var value = (StackValue)obj;
    return    this.Kind == value.Kind 
           && this.Flags == value.Flags 
           && this.Type == value.Type;
  }
}
 Entrar en modo pantalla completa Saír en modo pantalla completa PVS-Studio advertencia de:  Comparing value type variables with 'ReferenceEquals' is incorrect because 'this' will be boxed. ILImporter.StackValue.cs 164 Páxina 3161 A súa O método toma os parámetros da Cando se pasa un tipo de valor, obtén A referencia creada na pila non coincidirá con ningunha outra referencia. ReferenceEquals Object Boxeo Desde se pasa como o primeiro argumento, o boxeo ocorrerá cada vez que o O método é chamado. entón, comprobar a través de Sempre volve . this Equals ReferenceEquals false Ten en conta que este problema non afecta a forma en que funciona o método. método foi realizado para evitar máis comparacións se as referencias eran iguais. noutras palabras, esta é unha especie de optimización. ReferenceEquals 
 
 
 o código sempre se executa despois da verificación; Cada chamada a iguais resulta nunha operación de boxeo. É divertido que o analizador estea integrado en .NET (regra ) also detects this issue. However, the developers of .NET themselves couldn't avoid it :) CA2013 Quizais esta regra foi deshabilitada para o proxecto.  is enabled by default starting with .NET 5. Galicia 2013 4th place. Unsubscribing The fourth place goes to an error from an  : Artigo sobre a comprobación de MSBuild private static void SubscribeImmutablePathsInitialized()
{
  NotifyOnScopingReadiness?.Invoke();

  FileClassifier.Shared.OnImmutablePathsInitialized -= () =>
    NotifyOnScopingReadiness?.Invoke();
}
 Entrar en modo pantalla completa Saír en modo pantalla completa PVS-Studio warning:  A función Anónimo utilízase para cancelar a subscrición do evento 'OnImmutablePathsInitialized'.Non se cancelarán os administradores, xa que se crea unha instancia de delegado separada para cada declaración de función anónima. CheckScopeClassifier.cs 67 Páxina 3084 Neste caso, a cancelación da subscrición dun delegado non ten efecto porque cada vez que se declara unha función anónima, créase unha nova instancia de delegado. está subscrito ao Non se subscribe de que non ten efecto. OnImmutablePathsInitialized delegate 1 delegate 2 3rd place. Confusion over operator precedence Así, chegamos aos tres primeiros.O erro dun  takes the honorable third place: artigo sobre a comprobación dos proxectos Neo e NBitcoin public override int Size =>   base.Size
                            + ChangeViewMessages?.Values.GetVarSize() ?? 0
                            + 1 + PrepareRequestMessage?.Size ?? 0
                            + PreparationHash?.Size ?? 0
                            + PreparationMessages?.Values.GetVarSize() ?? 0
                            + CommitMessages?.Values.GetVarSize() ?? 0;
 Enter fullscreen mode Exit fullscreen mode PVS-Studio warning:  [CWE-783] Quizais o operador '??' funcione dun xeito diferente do esperado. A súa prioridade é inferior á prioridade doutros operadores na súa parte esquerda. V3123 Os expertos publicaron varios advertencias para este código, pero incluín só un para a brevidade. O operador ten menor precedencia que o Con todo, a formatación desta expresión suxire que os desenvolvedores esperaban o contrario. Páxina 3123 ?? + A orde das operacións importa aquí?Para responder á pregunta, imos ver o exemplo dunha adición de subexpresións se  is  : ChangeViewMessages null base.Size + ChangeViewMessages?.Values.GetVarSize() ?? 0
 Entrar en modo pantalla completa Saír en modo pantalla completa independentemente da  value, the sub-expression result is always 0 because adding   to  Resultados en . base.Size base.Size null null Se poñemos en parénteses, cambiando a orde da operación, o resultado . ChangeViewMessages?.Values.GetVarSize() ?? 0 base.Size 2o lugar: O patrón traidor O segundo lugar vai a un erro dun : artigo sobre a comprobación do xestor de ficheiros protected void ChangeMode(OmnibarMode? oldMode, OmnibarMode newMode)
{
  ....
  var modeSeparatorWidth = 
    itemCount is not 0 or 1 
      ? _modesHostGrid.Children[1] is FrameworkElement frameworkElement
        ? frameworkElement.ActualWidth
        : 0
      : 0;
  ....
}
 Enter fullscreen mode Exit fullscreen mode PVS-Studio advertencia de:  [CWE-670] The 'not 0 or 1' logical pattern may not work as expected. The 'not' pattern is matched only to the first expression from the 'or' pattern. Files.App.Controls Omnibar.cs 149 Páxina 3207 Vexamos máis de cerca a  part. Already guessed what's the issue? This pattern is redundant. Its second part affects nothing. itemCount is not 0 or 1 Cando se di "x non é 0 ou 1", a xente adoita implicar que x non é nin 0 nin 1. En realidade significa Tales erros poden levar non só a despedimentos, senón tamén a erros como Este tema tamén foi discutido en baseado na discusión, ou o compilador probablemente vai captar este problema no futuro, ou a análise estática incorporada vai marcalo como unha advertencia. x is not 0 or 1 x is (not 0) or 1 NullReferenceException: list is not null or list.Count == 0 Reunión Primeiro lugar.Como funciona LINQ? E o gañador é un erro dun Este erro ocupa o primeiro lugar debido á súa sutileza. Algúns desenvolvedores poden non considerar os efectos do uso de métodos de execución diferida en combinación coas variables capturadas. Artigo sobre a verificación do motor de negociación Lean public void FutureMarginModel_MarginEntriesValid(string market)
{
  ....
  var lineNumber = 0;
  var errorMessageTemplate = $"Error encountered in file " + 
                             $"{marginFile.Name} on line ";
  var csv = File.ReadLines(marginFile.FullName)
                .Where(x =>    !x.StartsWithInvariant("#") 
                            && !string.IsNullOrWhiteSpace(x))
                .Skip(1)
                .Select(x =>
  {
    lineNumber++;                                                  // <=

    ....
  });

  lineNumber = 0;                                                  // <=
  foreach (var line in csv)
  {
    lineNumber++;                                                  // <=

    ....
  }
}
 Entrar en modo pantalla completa Saír en modo pantalla completa PVS-Studio advertencia de: A variable 'lineNumber' foi cambiada despois de ser capturada nun método LINQ con execución diferida. O valor orixinal non se utilizará cando se executa o método. FutureMarginBuyingPowerModelTests.cs 720 Páxina 3219 A súa A variable é capturada e incrementada no delegado que se transmite ao método LINQ. é un método diferido, o código delegado é executado mentres se itera sobre a colección resultante, non cando que se chama. lineNumber Select Select While iterating over the  A colección, o variable tamén se incrementa. Como resultado, cada iteración aumenta : when the delegate runs and inside the  O que parece estraño. csv lineNumber lineNumber by 2 foreach Observa o Asignación antes É probable que os desenvolvedores esperasen que esta variable podería ter un valor non cero antes do loop. comeza en cero, e o único lugar que o cambia antes da Como se mencionou anteriormente, o delegado corre durante a iteración, non antes dela. Aparentemente, os desenvolvedores esperaban que o delegado executase antes de entrar no loop. lineNumber = 0 foreach lineNumber foreach Conclusion That's it! We've gone through the most interesting warnings from the author's point of view :) Espero que achei esta colección interesante e provocadora en termos de desenvolvemento de código. Se desexa comprobar se o seu proxecto ten problemas similares, agora é o momento de usar un analizador estático. . Descargar ligazón

Read My Stories

Este audio está producido na lingua orixinal da historia!

Os 10 erros de C# máis interesantes que atopamos en código aberto en 2025

About Author

COMENTARIOS

Etiquetas colgantes

ESTE ARTIGO FOI PRESENTADO EN

Related Stories

HackerNoon Decoded 2024: Celebrating Our Writing Community!

Coñece R Systems: HackerNoon empresa da semana

HackerNoon Decoded 2024: Celebrating Our Science Community!

HackerNoon Decoded 2024: Celebrating Our Life Hacking Community!

HackerNoon Decoded 2024: Celebrating Our Writing Community!

Coñece R Systems: HackerNoon empresa da semana

HackerNoon Decoded 2024: Celebrating Our Science Community!

HackerNoon Decoded 2024: Celebrating Our Life Hacking Community!

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps