Question

private struct TOKEN_USER
    {
        internal SID_AND_ATTRIBUTES User; //Compiler warning comes from here.
    }

[StructLayout(LayoutKind.Sequential)]
private struct SID_AND_ATTRIBUTES
   {
       internal IntPtr Sid;
       private int Attributes;
   }

将结构初始化为默认值：

TOKEN_USER tokenUser = default(TOKEN_USER);

然后进行两次必需的调用以检索指向结构的指针：（与问题无关）使用：

GetTokenInformation(tokenhandle, TokenInformationClass.TokenUser, sid, sidlength, ref sidlength);

然后编组回到结构。

tokenUser = (TOKEN_USER)Marshal.PtrToStructure(sid, tokenUser.GetType());

有效，但编译器警告我TOKEN_USER中的'User'字段未分配。

R＃建议我从构造函数初始化它：

public TOKEN_USER(SID_AND_ATTRIBUTES user) : this(user)
        {
        }

但是，这不会编译，错误“构造函数无法调用自身”。我的问题是，我应该将它分配给SID_AND_ATTRIBUTES（默认）以满足编译器的要求，还是忽略它？

测试程序：

   [DllImport("kernel32.dll", SetLastError = true)]
    private static extern IntPtr OpenProcess(
        int dwDesiredAccess,
        [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle,
        int dwProcessId);

    [DllImport("advapi32.dll", SetLastError = true)]
    private static extern bool OpenProcessToken(
        IntPtr processHandle,
        int desiredAccess,
        ref IntPtr TokenHandle);

    [DllImport("advapi32.dll", SetLastError = true)]
    private static extern bool GetTokenInformation(
        IntPtr tokenHandle,
        TokenInformationClass tokenInformationClass,
        IntPtr tokenInformation,
        int TokenInformationLength,
        ref int ReturnLength);

    [DllImport("advapi32.dll", SetLastError = true)]
    private static extern bool IsValidSid(
        IntPtr SID);


    private enum TokenInformationClass
    {
        TokenUser = 1,
    }

    private const int QueryInformation = 0x400;

    private const int TokenRead = 0x20008;

    private struct TOKEN_USER
    {
        internal SID_AND_ATTRIBUTES User; //Compiler warning comes from here.
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct SID_AND_ATTRIBUTES
    {
        internal IntPtr Sid;
        private int Attributes;
    }



    internal static IntPtr GetProcessHandle()
    {
        foreach (Process p in Process.GetProcesses())
        {
            using (p)
            {
                if (p.ProcessName == "explorer")
                {
                    return OpenProcess(QueryInformation, false, p.Id);
                }
            }
        }
        return IntPtr.Zero;
    }

    public void Test()
    {
        IntPtr pHandle = GetProcessHandle();

        IntPtr tokenHandle = IntPtr.Zero;
        OpenProcessToken(pHandle, TokenRead, ref tokenHandle);

        int sidlength = 0;
        GetTokenInformation(tokenHandle, TokenInformationClass.TokenUser, IntPtr.Zero, 
0, ref sidlength);

        TOKEN_USER tokenUser = default(TOKEN_USER);
        IntPtr sid = Marshal.AllocHGlobal(sidlength);

        GetTokenInformation(tokenHandle, TokenInformationClass.TokenUser,sid, 
sidlength, ref sidlength);

        tokenUser = (TOKEN_USER)Marshal.PtrToStructure(sid, tokenUser.GetType());


        if (IsValidSid(tokenUser.User.Sid))
        {
            Debug.WriteLine("Valid!");
        }
    }

Answer 1

每次使用通过某种外部机制初始化的类型时，您都会看到此警告，例如反射或（如此处）Marshal类。问题是编译器无法知道该字段是如何初始化的;所有它可以看到的是类型本身，并且类型中没有任何东西可以初始化该字段。

由于声明一个从未赋值的字段通常是编码错误，编译器会为该情况生成警告。

我不确定R＃的确切建议是什么，但显然你不能使用与你声明的相同的构造函数重载，因为这会创建一个无限递归的初始化。

在某些情况下，使用struct初始化: this()是有意义的（即调用默认构造函数），但这样做是为了处理您想要访问字段的问题或者构造函数中的属性，直到它被初始化（调用this()构造函数初始化整个对象）。也许这就是R＃＆＃34;思考＆＃34;的？

无论如何，我在这种情况下的做法只是禁用警告，因为我知道这肯定是误报。我做初始化字段，只是不是编译器知道的方式。您可以使用#pragma warning指令完成此操作。 E.g：

private struct TOKEN_USER
{
    #pragma warning disable 0649
    internal SID_AND_ATTRIBUTES User;
    #pragma warning restore 0649
}

请参阅Suppressing “is never used” and “is never assigned to” warnings答案的相关讨论。在那里，建议您添加一条注释，解释警告被禁用的原因以及为什么这样做是安全的;恕我直言，在任何情况下你都禁用了警告，这是一个非常好的主意。

field＆＃39; FIELD＆＃39;永远不会分配给，并且将始终具有其默认值

1 个答案: