PVS-સ્ટુડિયો હવે ચોકલેટીમાં છે: Azure DevOps હેઠળ ચોકલેટીને તપાસી રહ્યું છે

અમે PVS-સ્ટુડિયોનો ઉપયોગ વધુ અનુકૂળ બનાવવાનું ચાલુ રાખીએ છીએ. અમારું વિશ્લેષક હવે ચોકલેટીમાં ઉપલબ્ધ છે, જે Windows માટે પેકેજ મેનેજર છે. અમે માનીએ છીએ કે આ PVS-સ્ટુડિયોની જમાવટને સરળ બનાવશે, ખાસ કરીને, ક્લાઉડ સેવાઓમાં. દૂર ન જવા માટે, ચાલો તે જ ચોકલેટીનો સ્રોત કોડ તપાસીએ. Azure DevOps CI સિસ્ટમ તરીકે કાર્ય કરશે.

અહીં ક્લાઉડ સિસ્ટમ્સ સાથે એકીકરણના વિષય પરના અમારા અન્ય લેખોની સૂચિ છે:

• PVS-સ્ટુડિયો વાદળોમાં જાય છે: Azure DevOps
• પીવીએસ-સ્ટુડિયો વાદળોમાં જાય છે: ટ્રેવિસ સીઆઈ
• PVS-સ્ટુડિયો વાદળોમાં જાય છે: CircleCI
• PVS-સ્ટુડિયો વાદળો પર જાય છે: GitLab CI/CD

હું તમને સલાહ આપું છું કે Azure DevOps સાથે એકીકરણ વિશેના પ્રથમ લેખ પર ધ્યાન આપો, કારણ કે આ કિસ્સામાં કેટલાક મુદ્દાઓ અવગણવામાં આવ્યા છે જેથી ડુપ્લિકેટ ન થાય.

તેથી, આ લેખના હીરો:

પીવીએસ-સ્ટુડિયો એ સ્ટેટિક કોડ વિશ્લેષણ સાધન છે જે C, C++, C# અને Java માં લખાયેલા પ્રોગ્રામ્સમાં ભૂલો અને સંભવિત નબળાઈઓને ઓળખવા માટે રચાયેલ છે. 64-બીટ વિન્ડોઝ, લિનક્સ અને મેકઓએસ સિસ્ટમ્સ પર ચાલે છે અને 32-બીટ, 64-બીટ અને એમ્બેડેડ એઆરએમ પ્લેટફોર્મ માટે રચાયેલ કોડનું વિશ્લેષણ કરી શકે છે. જો તમે તમારા પ્રોજેક્ટને તપાસવા માટે સ્ટેટિક કોડ વિશ્લેષણનો આ પ્રથમ વખત પ્રયાસ કરી રહ્યાં છો, તો અમે ભલામણ કરીએ છીએ કે તમે તમારી જાતને તેનાથી પરિચિત થાઓ લેખ સૌથી રસપ્રદ PVS-Studio ચેતવણીઓ કેવી રીતે ઝડપથી જોવી અને આ સાધનની ક્ષમતાઓનું મૂલ્યાંકન કેવી રીતે કરવું તે વિશે.

એઝુર ડેવઓપ્સ - ક્લાઉડ સેવાઓનો સમૂહ જે સંયુક્ત રીતે સમગ્ર વિકાસ પ્રક્રિયાને આવરી લે છે. આ પ્લેટફોર્મમાં Azure Pipelines, Azure Boards, Azure Artifacts, Azure Repos, Azure Test Plans જેવા સાધનોનો સમાવેશ થાય છે, જે તમને સોફ્ટવેર બનાવવાની પ્રક્રિયાને ઝડપી બનાવવા અને તેની ગુણવત્તા સુધારવા માટે પરવાનગી આપે છે.

ચોકલેટ Windows માટે ઓપન સોર્સ પેકેજ મેનેજર છે. પ્રોજેક્ટનો ધ્યેય વિન્ડોઝ ઓપરેટિંગ સિસ્ટમ્સ પર ઇન્સ્ટોલેશનથી અપડેટ અને અનઇન્સ્ટોલેશન સુધીના સમગ્ર સોફ્ટવેર જીવનચક્રને સ્વચાલિત કરવાનો છે.

ચોકલેટીના ઉપયોગ વિશે

તમે આમાં પેકેજ મેનેજરને કેવી રીતે ઇન્સ્ટોલ કરવું તે જોઈ શકો છો કડી. વિશ્લેષક ઇન્સ્ટોલ કરવા માટેના સંપૂર્ણ દસ્તાવેજો અહીં ઉપલબ્ધ છે કડી ચોકલેટી પેકેજ મેનેજર વિભાગનો ઉપયોગ કરીને ઇન્સ્ટોલેશન જુઓ. હું સંક્ષિપ્તમાં ત્યાંથી કેટલાક મુદ્દાઓનું પુનરાવર્તન કરીશ.

વિશ્લેષકના નવીનતમ સંસ્કરણને ઇન્સ્ટોલ કરવાનો આદેશ:

choco install pvs-studio

PVS-Studio પૅકેજનું ચોક્કસ વર્ઝન ઇન્સ્ટૉલ કરવાનો આદેશ:

choco install pvs-studio --version=7.05.35617.2075

મૂળભૂત રીતે, માત્ર વિશ્લેષકનો મુખ્ય ભાગ, મુખ્ય ઘટક, સ્થાપિત થયેલ છે. અન્ય તમામ ફ્લેગ્સ (સ્ટેન્ડઅલોન, JavaCore, IDEA, MSVS2010, MSVS2012, MSVS2013, MSVS2015, MSVS2017, MSVS2019) --package-parameters નો ઉપયોગ કરીને પસાર કરી શકાય છે.

આદેશનું ઉદાહરણ જે વિઝ્યુઅલ સ્ટુડિયો 2019 માટે પ્લગઇન સાથે વિશ્લેષક ઇન્સ્ટોલ કરશે:

choco install pvs-studio --package-parameters="'/MSVS2019'"

હવે ચાલો Azure DevOps હેઠળ વિશ્લેષકના અનુકૂળ ઉપયોગનું ઉદાહરણ જોઈએ.

ગોઠવણ

હું તમને યાદ કરાવું કે એકાઉન્ટ રજીસ્ટર કરવા, બિલ્ડ પાઇપલાઇન બનાવવા અને તમારા એકાઉન્ટને GitHub રિપોઝીટરીમાં સ્થિત પ્રોજેક્ટ સાથે સિંક્રનાઇઝ કરવા જેવી સમસ્યાઓ વિશે એક અલગ વિભાગ છે. લેખ. અમારું સેટઅપ તરત જ રૂપરેખાંકન ફાઇલ લખવાથી શરૂ થશે.

પ્રથમ, ચાલો લોન્ચ ટ્રિગર સેટ કરીએ, જે દર્શાવે છે કે અમે ફક્ત માં ફેરફારો માટે જ લોન્ચ કરીએ છીએ માસ્ટર શાખા:

trigger:
- master

આગળ આપણે વર્ચ્યુઅલ મશીન પસંદ કરવાની જરૂર છે. હમણાં માટે તે Windows સર્વર 2019 અને વિઝ્યુઅલ સ્ટુડિયો 2019 સાથે માઇક્રોસોફ્ટ-હોસ્ટેડ એજન્ટ હશે:

pool:
  vmImage: 'windows-latest'

ચાલો રૂપરેખાંકન ફાઇલના મુખ્ય ભાગમાં આગળ વધીએ (block પગલાંઓ). તમે વર્ચ્યુઅલ મશીનમાં મનસ્વી સૉફ્ટવેર ઇન્સ્ટોલ કરી શકતા નથી તે હકીકત હોવા છતાં, મેં ડોકર કન્ટેનર ઉમેર્યું નથી. અમે Azure DevOps માટે એક્સ્ટેંશન તરીકે Chocolatey ઉમેરી શકીએ છીએ. આ કરવા માટે, ચાલો જઈએ કડી. ક્લિક કરો તે મફતમાં મેળવો. આગળ, જો તમે પહેલેથી જ અધિકૃત છો, તો ફક્ત તમારું એકાઉન્ટ પસંદ કરો, અને જો નહીં, તો અધિકૃતતા પછી તે જ કરો.

અહીં તમારે પસંદ કરવાની જરૂર છે કે અમે એક્સ્ટેંશન ક્યાં ઉમેરીશું અને બટન પર ક્લિક કરો ઇન્સ્ટોલ કરો.

સફળ ઇન્સ્ટોલેશન પછી, ક્લિક કરો સંસ્થામાં આગળ વધો:

હવે તમે વિન્ડોમાં ચોકલેટી કાર્ય માટેનો નમૂનો જોઈ શકો છો કાર્યો જ્યારે રૂપરેખાંકન ફાઈલમાં ફેરફાર કરી રહ્યા હોય azure-pipelines.yml:

ચોકલેટી પર ક્લિક કરો અને ફીલ્ડ્સની સૂચિ જુઓ:

અહીં આપણે પસંદ કરવાની જરૂર છે ઇન્સ્ટોલ કરો ટીમો સાથે મેદાનમાં. IN Nuspec ફાઇલનું નામ જરૂરી પેકેજનું નામ સૂચવો - pvs-studio. જો તમે સંસ્કરણનો ઉલ્લેખ કરતા નથી, તો નવીનતમ ઇન્સ્ટોલ કરવામાં આવશે, જે અમને સંપૂર્ણપણે અનુકૂળ છે. ચાલો બટન દબાવીએ ઉમેરવું અને આપણે રૂપરેખાંકન ફાઈલમાં જનરેટ થયેલ કાર્ય જોઈશું.

steps:
- task: ChocolateyCommand@0
  inputs:
    command: 'install'
    installPackageId: 'pvs-studio'

આગળ, ચાલો આપણી ફાઇલના મુખ્ય ભાગ પર જઈએ:

- task: CmdLine@2
  inputs:
    script: 

હવે આપણે વિશ્લેષક લાઇસન્સ સાથે ફાઇલ બનાવવાની જરૂર છે. અહીં PVSNAME и PVSKEY - ચલોના નામ જેના મૂલ્યો આપણે સેટિંગ્સમાં સ્પષ્ટ કરીએ છીએ. તેઓ PVS-Studio લૉગિન અને લાઇસન્સ કી સ્ટોર કરશે. તેમના મૂલ્યો સેટ કરવા માટે, મેનૂ ખોલો ચલ->નવું ચલ. ચાલો ચલ બનાવીએ PVSNAME પ્રવેશ માટે અને PVSKEY વિશ્લેષક કી માટે. બૉક્સને ચેક કરવાનું ભૂલશો નહીં આ મૂલ્ય ગુપ્ત રાખો માટે PVSKEY. આદેશ કોડ:

сall "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" credentials 
–u $(PVSNAME) –n $(PVSKEY)

ચાલો રીપોઝીટરીમાં સ્થિત બેટ ફાઇલનો ઉપયોગ કરીને પ્રોજેક્ટ બનાવીએ:

сall build.bat

ચાલો એક ફોલ્ડર બનાવીએ જ્યાં વિશ્લેષકના પરિણામો સાથેની ફાઇલો સંગ્રહિત કરવામાં આવશે:

сall mkdir PVSTestResults

ચાલો પ્રોજેક્ટનું વિશ્લેષણ કરવાનું શરૂ કરીએ:

сall "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" 
–t .srcchocolatey.sln –o .PVSTestResultsChoco.plog 

અમે PlogConverter ઉપયોગિતાનો ઉપયોગ કરીને અમારા રિપોર્ટને html ફોર્મેટમાં કન્વર્ટ કરીએ છીએ:

сall "C:Program Files (x86)PVS-StudioPlogConverter.exe" 
–t html –o PVSTestResults .PVSTestResultsChoco.plog

હવે તમારે એક કાર્ય બનાવવાની જરૂર છે જેથી કરીને તમે રિપોર્ટ અપલોડ કરી શકો.

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: PVSTestResults
    artifactName: PVSTestResults
    condition: always()

સંપૂર્ણ રૂપરેખાંકન ફાઇલ આના જેવી દેખાય છે:

trigger:
- master

pool:
  vmImage: 'windows-latest'

steps:
- task: ChocolateyCommand@0
  inputs:
    command: 'install'
    installPackageId: 'pvs-studio'

- task: CmdLine@2
  inputs:
    script: |
      call "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" 
      credentials –u $(PVSNAME) –n $(PVSKEY)
      call build.bat
      call mkdir PVSTestResults
      call "C:Program Files (x86)PVS-StudioPVS-Studio_Cmd.exe" 
      –t .srcchocolatey.sln –o .PVSTestResultsChoco.plog
      call "C:Program Files (x86)PVS-StudioPlogConverter.exe" 
      –t html –o .PVSTestResults .PVSTestResultsChoco.plog

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: PVSTestResults
    artifactName: PVSTestResults
    condition: always()

ચાલો ક્લિક કરીએ સેવ->સેવ->રન કાર્ય ચલાવવા માટે. ચાલો ટાસ્ક ટેબ પર જઈને રિપોર્ટ ડાઉનલોડ કરીએ.

ચોકલેટી પ્રોજેક્ટમાં C# કોડની માત્ર 37615 રેખાઓ છે. ચાલો કેટલીક ભૂલો શોધી કાઢીએ.

પરીક્ષા નું પરિણામ

ચેતવણી N1

વિશ્લેષક ચેતવણી: V3005 'પ્રોવાઇડર' ચલ પોતે જ સોંપાયેલ છે. CrytpoHashProviderSpecs.cs 38

public abstract class CrytpoHashProviderSpecsBase : TinySpec
{
  ....
  protected CryptoHashProvider Provider;
  ....
  public override void Context()
  {
    Provider = Provider = new CryptoHashProvider(FileSystem.Object);
  }
}

વિશ્લેષકે પોતાને માટે વેરીએબલની સોંપણી શોધી કાઢી, જેનો કોઈ અર્થ નથી. મોટે ભાગે, આ ચલોમાંના એકની જગ્યાએ કોઈ બીજું હોવું જોઈએ. સારું, અથવા આ એક ટાઇપો છે, અને વધારાની સોંપણી ખાલી દૂર કરી શકાય છે.

ચેતવણી N2

વિશ્લેષક ચેતવણી: V3093 [CWE-480] '&' ઓપરેટર બંને ઓપરેન્ડનું મૂલ્યાંકન કરે છે. કદાચ તેના બદલે શોર્ટ-સર્કિટ '&&' ઓપરેટરનો ઉપયોગ કરવો જોઈએ. Platform.cs 64

public static PlatformType get_platform()
{
  switch (Environment.OSVersion.Platform)
  {
    case PlatformID.MacOSX:
    {
      ....
    }
    case PlatformID.Unix:
    if(file_system.directory_exists("/Applications")
      & file_system.directory_exists("/System")
      & file_system.directory_exists("/Users")
      & file_system.directory_exists("/Volumes"))
      {
        return PlatformType.Mac;
      }
        else
          return PlatformType.Linux;
    default:
      return PlatformType.Windows;
  }
}

ઓપરેટર તફાવત & ઓપરેટર પાસેથી && તે છે જો અભિવ્યક્તિની ડાબી બાજુ છે ખોટું, પછી જમણી બાજુ હજુ પણ ગણતરી કરવામાં આવશે, જે આ કિસ્સામાં બિનજરૂરી પદ્ધતિ કૉલ્સ સૂચવે છે system.directory_exists.

ધ્યાનમાં લેવાયેલા ટુકડામાં, આ એક નાની ખામી છે. હા, આ સ્થિતિ & ઓપરેટરને && ઓપરેટર સાથે બદલીને ઑપ્ટિમાઇઝ કરી શકાય છે, પરંતુ વ્યવહારિક દૃષ્ટિકોણથી, આ કંઈપણ અસર કરતું નથી. જો કે, અન્ય કિસ્સાઓમાં, જ્યારે અભિવ્યક્તિની જમણી બાજુને ખોટા/અમાન્ય મૂલ્યો સાથે ગણવામાં આવે ત્યારે & અને && વચ્ચેની મૂંઝવણ ગંભીર સમસ્યાઓનું કારણ બની શકે છે. ઉદાહરણ તરીકે, અમારા ભૂલ સંગ્રહમાં, V3093 ડાયગ્નોસ્ટિકનો ઉપયોગ કરીને ઓળખવામાં આવે છે, આ કેસ છે:

if ((k < nct) & (s[k] != 0.0))

ભલે ઇન્ડેક્સ k ખોટું છે, તેનો ઉપયોગ એરે એલિમેન્ટને ઍક્સેસ કરવા માટે થશે. પરિણામે, અપવાદ ફેંકવામાં આવશે IndexOutOfRangeException.

ચેતવણીઓ N3, N4

વિશ્લેષક ચેતવણી: V3022 [CWE-571] અભિવ્યક્તિ 'શોર્ટ પ્રોમ્પ્ટ' હંમેશા સાચી હોય છે. InteractivePrompt.cs 101
વિશ્લેષક ચેતવણી: V3022 [CWE-571] અભિવ્યક્તિ 'શોર્ટ પ્રોમ્પ્ટ' હંમેશા સાચી હોય છે. InteractivePrompt.cs 105

public static string 
prompt_for_confirmation(.... bool shortPrompt = false, ....)
{
  ....
  if (shortPrompt)
  {
    var choicePrompt = choice.is_equal_to(defaultChoice) //1
    ?
    shortPrompt //2
    ?
    "[[{0}]{1}]".format_with(choice.Substring(0, 1).ToUpperInvariant(), //3
    choice.Substring(1,choice.Length - 1))
    :
    "[{0}]".format_with(choice.ToUpperInvariant()) //0
    : 
    shortPrompt //4
    ? 
    "[{0}]{1}".format_with(choice.Substring(0,1).ToUpperInvariant(), //5
    choice.Substring(1,choice.Length - 1)) 
    :
    choice; //0
    ....
  }
  ....
}

આ કિસ્સામાં, ટર્નરી ઓપરેટરની કામગીરી પાછળ એક વિચિત્ર તર્ક છે. ચાલો નજીકથી નજર કરીએ: જો મેં નંબર 1 સાથે ચિહ્નિત કરેલી શરત પૂરી થાય, તો આપણે શરત 2 પર આગળ વધીશું, જે હંમેશા સાચું, જેનો અર્થ થાય છે કે લાઇન 3 ચલાવવામાં આવશે. જો શરત 1 ખોટી હોવાનું બહાર આવે છે, તો આપણે નંબર 4 સાથે ચિહ્નિત થયેલ લાઇન પર જઈશું, જે શરત હંમેશા હોય છે. સાચું, જેનો અર્થ છે કે પંક્તિ 5 અમલમાં આવશે. આમ, ટિપ્પણી 0 સાથે ચિહ્નિત થયેલ શરતો ક્યારેય પરિપૂર્ણ થશે નહીં, જે પ્રોગ્રામર દ્વારા અપેક્ષિત કામગીરીનો તર્ક બરાબર ન હોઈ શકે.

ચેતવણી N5

વિશ્લેષક ચેતવણી: V3123 [CWE-783] કદાચ '?:' ઓપરેટર અપેક્ષા કરતા અલગ રીતે કામ કરે છે. તેની પ્રાથમિકતા તેની સ્થિતિમાં અન્ય ઓપરેટરોની પ્રાથમિકતા કરતાં ઓછી છે. Options.cs 1019

private static string GetArgumentName (...., string description)
{
  string[] nameStart;
  if (maxIndex == 1)
  {
    nameStart = new string[]{"{0:", "{"};
  }
  else
  {
    nameStart = new string[]{"{" + index + ":"};
  }
  for (int i = 0; i < nameStart.Length; ++i) 
  {
    int start, j = 0;
    do 
    {
      start = description.IndexOf (nameStart [i], j);
    } 
    while (start >= 0 && j != 0 ? description [j++ - 1] == '{' : false);
    ....
    return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1);
  }
}

ડાયગ્નોસ્ટિક એ લાઇન માટે કામ કર્યું:

while (start >= 0 && j != 0 ? description [j++ - 1] == '{' : false)

ચલ થી j ઉપરની કેટલીક લીટીઓ શૂન્યથી શરૂ કરવામાં આવી છે, ટર્નરી ઓપરેટર મૂલ્ય પરત કરશે ખોટું. આ સ્થિતિને કારણે, લૂપનું શરીર ફક્ત એક જ વાર ચલાવવામાં આવશે. મને લાગે છે કે કોડનો આ ભાગ પ્રોગ્રામરના હેતુ મુજબ કામ કરતું નથી.

ચેતવણી N6

વિશ્લેષક ચેતવણી: V3022 [CWE-571] અભિવ્યક્તિ 'installedPackageVersions.Count != 1' હંમેશા સાચી હોય છે. NugetService.cs 1405

private void remove_nuget_cache_for_package(....)
{
  if (!config.AllVersions && installedPackageVersions.Count > 1)
  {
    const string allVersionsChoice = "All versions";
    if (installedPackageVersions.Count != 1)
    {
      choices.Add(allVersionsChoice);
    }
    ....
  }
  ....
}

અહીં એક વિચિત્ર નેસ્ટેડ સ્થિતિ છે: InstallPackageVersions.Count != 1જે હંમેશા રહેશે સાચું. ઘણીવાર આવી ચેતવણી કોડમાં તાર્કિક ભૂલ સૂચવે છે, અને અન્ય કિસ્સાઓમાં તે ફક્ત બિનજરૂરી ચકાસણી સૂચવે છે.

ચેતવણી N7

વિશ્લેષક ચેતવણી: V3001 '||' ની ડાબી અને જમણી બાજુએ સમાન પેટા-અભિવ્યક્તિઓ 'commandArguments.contains("-apikey")' છે. ઓપરેટર ArgumentsUtility.cs 42

public static bool arguments_contain_sensitive_information(string
 commandArguments)
{
  return commandArguments.contains("-install-arguments-sensitive")
  || commandArguments.contains("-package-parameters-sensitive")
  || commandArguments.contains("apikey ")
  || commandArguments.contains("config ")
  || commandArguments.contains("push ")
  || commandArguments.contains("-p ")
  || commandArguments.contains("-p=")
  || commandArguments.contains("-password")
  || commandArguments.contains("-cp ")
  || commandArguments.contains("-cp=")
  || commandArguments.contains("-certpassword")
  || commandArguments.contains("-k ")
  || commandArguments.contains("-k=")
  || commandArguments.contains("-key ")
  || commandArguments.contains("-key=")
  || commandArguments.contains("-apikey")
  || commandArguments.contains("-api-key")
  || commandArguments.contains("-apikey")
  || commandArguments.contains("-api-key");
}

કોડનો આ વિભાગ લખનાર પ્રોગ્રામરે છેલ્લી બે લીટીઓ કોપી અને પેસ્ટ કરી અને તેને સંપાદિત કરવાનું ભૂલી ગયા. આ કારણે, ચોકલેટી વપરાશકર્તાઓ પેરામીટર લાગુ કરવામાં અસમર્થ હતા apikey થોડી વધુ રીતો. ઉપરના પરિમાણોની જેમ, હું નીચેના વિકલ્પો ઑફર કરી શકું છું:

commandArguments.contains("-apikey=");
commandArguments.contains("-api-key=");

કોપી-પેસ્ટ ભૂલો મોટા પ્રમાણમાં સ્ત્રોત કોડ સાથેના કોઈપણ પ્રોજેક્ટમાં વહેલા અથવા પછીના દેખાવાની ઉચ્ચ તક ધરાવે છે, અને તેનો સામનો કરવા માટેનું એક શ્રેષ્ઠ સાધન સ્થિર વિશ્લેષણ છે.

PS અને હંમેશની જેમ, આ ભૂલ મલ્ટિ-લાઇન શરતના અંતે દેખાય છે :). પ્રકાશન જુઓ "છેલ્લી લાઇનની અસર".

ચેતવણી N8

વિશ્લેષક ચેતવણી: V3095 [CWE-476] 'ઇન્સ્ટોલ કરેલ પેકેજ' ઑબ્જેક્ટ નલ સામે ચકાસવામાં આવે તે પહેલાં તેનો ઉપયોગ કરવામાં આવ્યો હતો. રેખાઓ તપાસો: 910, 917. NugetService.cs 910

public virtual ConcurrentDictionary<string, PackageResult> get_outdated(....)
{
  ....
  var pinnedPackageResult = outdatedPackages.GetOrAdd(
    packageName, 
    new PackageResult(installedPackage, 
                      _fileSystem.combine_paths(
                        ApplicationParameters.PackagesLocation, 
                        installedPackage.Id)));
  ....
  if (   installedPackage != null
      && !string.IsNullOrWhiteSpace(installedPackage.Version.SpecialVersion) 
      && !config.UpgradeCommand.ExcludePrerelease)
  {
    ....
  }
  ....
}

ઉત્તમ ભૂલ: પ્રથમ વસ્તુ ઇન્સ્ટોલ કરેલ પેકેજ ઉપયોગ થાય છે અને પછી તપાસવામાં આવે છે નલ. આ ડાયગ્નોસ્ટિક અમને પ્રોગ્રામમાં બેમાંથી એક સમસ્યા વિશે જણાવે છે: ક્યાં તો ઇન્સ્ટોલ કરેલ પેકેજ ક્યારેય સમાન નથી નલ, જે શંકાસ્પદ છે, અને પછી ચેક રીડન્ડન્ટ છે, અથવા અમને સંભવતઃ કોડમાં ગંભીર ભૂલ મળી શકે છે - નલ સંદર્ભને ઍક્સેસ કરવાનો પ્રયાસ.

નિષ્કર્ષ

તેથી અમે બીજું નાનું પગલું ભર્યું છે - હવે PVS-Studio નો ઉપયોગ વધુ સરળ અને વધુ અનુકૂળ બની ગયો છે. હું એ પણ કહેવા માંગુ છું કે ચોકલેટી એ કોડમાં નાની સંખ્યામાં ભૂલો સાથે એક સારો પેકેજ મેનેજર છે, જે PVS-સ્ટુડિયોનો ઉપયોગ કરતી વખતે પણ ઓછી હોઈ શકે છે.

અમે તમને આમંત્રણ આપીએ છીએ скачать અને PVS-Studio અજમાવી જુઓ. સ્થિર વિશ્લેષકનો નિયમિત ઉપયોગ તમારી ટીમ જે કોડ વિકસાવે છે તેની ગુણવત્તા અને વિશ્વસનીયતામાં સુધારો કરશે અને ઘણાને રોકવામાં મદદ કરશે શૂન્ય દિવસની નબળાઈઓ.

PS

પ્રકાશન પહેલાં, અમે લેખ ચોકલેટી વિકાસકર્તાઓને મોકલ્યો હતો, અને તેઓને તે સારી રીતે મળ્યો હતો. અમને કંઈપણ જટિલ લાગ્યું નથી, પરંતુ તેઓને, ઉદાહરણ તરીકે, અમને "api-key" કી સાથે સંબંધિત બગ ગમ્યું.

જો તમે આ લેખ અંગ્રેજી બોલતા પ્રેક્ષકો સાથે શેર કરવા માંગતા હો, તો કૃપા કરીને અનુવાદ લિંકનો ઉપયોગ કરો: Vladislav Stolyarov. PVS-સ્ટુડિયો હવે ચોકલેટીમાં છે: Azure DevOps હેઠળ ચોકલેટી તપાસી રહ્યું છે.

સોર્સ: www.habr.com