C# 如何检查类是否在工厂中实现接口方法

我有两个文件。其中一个是类声明，另一个是接口声明。类应该实现接口。如果类实现了接口方法，我如何签入NRefactory

我应该提供更多的细节

第一个文件-例如：

class Test : IF
{
}

第二个呢

interface IF
{
    void Foo();
}

我必须阅读这些文件，并用NRefactory进行解析。我需要检查类测试是否从接口if实现了方法

---

不编译和加载已编译的程序集。

使用

is

关键字

---

使用

is

关键字

---

或者，您也可以将

用作

关键字

class MyClass {  }
interface IInterface {  }

MyClass instance = new MyClass();
var inst = instance as IInterface;
if (inst != null)
{
    // your class implements the interface
}

当您需要该实例时，请使用此选项，然后再使用，而无需额外的引用键入。使用

是

您仍然需要执行的操作

if (instance is IInterface) 
{
    var inst = (IInterface) instance;
}

或

---

所以为什么不马上做呢。

或者，你也可以使用

作为关键字

class MyClass {  }
interface IInterface {  }

MyClass instance = new MyClass();
var inst = instance as IInterface;
if (inst != null)
{
    // your class implements the interface
}

当您需要该实例时，请使用此选项，然后再使用，而无需额外的引用键入。使用
是
您仍然需要执行的操作

if (instance is IInterface) 
{
    var inst = (IInterface) instance;
}

或

所以为什么不马上做呢。
我在NRefactory代码中找到了解决方案。为了实现我的目标，我修改了这个。首先，我们应该实现visitor，它检查类是否从接口实现了每个方法：

public class MissingInterfaceMemberImplementationVisitor : DepthFirstAstVisitor
{
    private readonly CSharpAstResolver _resolver;
    public bool IsInterfaceMemberMissing { get; private set; }
    public MissingInterfaceMemberImplementationVisitor(CSharpAstResolver resolver)
    {
        _resolver = resolver;
        IsInterfaceMemberMissing = false;
    }

    public override void VisitTypeDeclaration(TypeDeclaration typeDeclaration)
    {
        if (typeDeclaration.ClassType == ClassType.Interface || typeDeclaration.ClassType == ClassType.Enum)
            return;
        base.VisitTypeDeclaration(typeDeclaration);
        var rr = _resolver.Resolve(typeDeclaration);
        if (rr.IsError)
            return;
        foreach (var baseType in typeDeclaration.BaseTypes)
        {
            var bt = _resolver.Resolve(baseType);
            if (bt.IsError || bt.Type.Kind != TypeKind.Interface)
                continue;
            bool interfaceMissing;
            var toImplement = ImplementInterfaceAction.CollectMembersToImplement(rr.Type.GetDefinition(), bt.Type, false, out interfaceMissing);
            if (toImplement.Count == 0)
                continue;

            IsInterfaceMemberMissing = true;
        }
    }
}

现在我们必须读取所有文件，解析它们，并以以下方式调用上述类：

var solutionFiles = new List<FileInfo>();
var trees = new Dictionary<FileInfo, SyntaxTree>();
IProjectContent projectContent = new CSharpProjectContent();
foreach (var file in solutionFiles.Where(f => f.Extension == ".cs").Distinct())
{
    var parser = new ICSharpCode.NRefactory.CSharp.CSharpParser();
    SyntaxTree syntaxTree;
    using (var fs = new FileStream(file.FullName, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan))
    {
        syntaxTree = parser.Parse(fs, file.FullName);
    }
    trees.Add(file, syntaxTree);
    var unresolvedFile = syntaxTree.ToTypeSystem();
    projectContent = projectContent.AddOrUpdateFiles(unresolvedFile);
}
var compilation = projectContent.CreateCompilation();

foreach (var sharpFile in trees)
{
    var originalResolver = new CSharpAstResolver(compilation, sharpFile.Value, sharpFile.Value.ToTypeSystem());
    var visitor = new MissingInterfaceMemberImplementationVisitor(originalResolver);
    sharpFile.Value.AcceptVisitor(visitor);
    if (visitor.IsInterfaceMemberMissing)
       return false;
    }
return true;

var solutionFiles=new List（）；
var trees=newdictionary（）；
IProjectContent projectContent=new CSharpProjectContent（）；
foreach（solutionFiles.Where（f=>f.Extension==“.cs”）.Distinct（）中的var文件）
{
var parser=new ICSharpCode.NRefactory.CSharp.CSharpParser（）；
合成树；
使用（var fs=new FileStream（file.FullName，FileMode.Open，FileAccess.Read，FileShare.Read，4096，FileOptions.SequentialScan））
{
syntaxTree=parser.Parse（fs，file.FullName）；
}
添加（文件，语法树）；
var unsolvedfile=syntaxTree.ToTypeSystem（）；
projectContent=projectContent.AddOrUpdateFiles（unsolvedfile）；
}
var compilation=projectContent.CreateCompilation（）；
foreach（树中的文件）
{
var originalResolver=new CSharpAstResolver（编译，sharpFile.Value，sharpFile.Value.ToTypeSystem（））；
var visitor=新的MissingInterfaceMemberImplementationVisitor（原始解析程序）；
sharpFile.Value.AcceptVisitor（visitor）；
if（visitor.IsInterfaceMemberMissing）
返回false；
}
返回true；
我在工厂代码中找到了解决方案。为了实现我的目标，我修改了这个。首先，我们应该实现visitor，它检查类是否从接口实现了每个方法：

public class MissingInterfaceMemberImplementationVisitor : DepthFirstAstVisitor
{
    private readonly CSharpAstResolver _resolver;
    public bool IsInterfaceMemberMissing { get; private set; }
    public MissingInterfaceMemberImplementationVisitor(CSharpAstResolver resolver)
    {
        _resolver = resolver;
        IsInterfaceMemberMissing = false;
    }

    public override void VisitTypeDeclaration(TypeDeclaration typeDeclaration)
    {
        if (typeDeclaration.ClassType == ClassType.Interface || typeDeclaration.ClassType == ClassType.Enum)
            return;
        base.VisitTypeDeclaration(typeDeclaration);
        var rr = _resolver.Resolve(typeDeclaration);
        if (rr.IsError)
            return;
        foreach (var baseType in typeDeclaration.BaseTypes)
        {
            var bt = _resolver.Resolve(baseType);
            if (bt.IsError || bt.Type.Kind != TypeKind.Interface)
                continue;
            bool interfaceMissing;
            var toImplement = ImplementInterfaceAction.CollectMembersToImplement(rr.Type.GetDefinition(), bt.Type, false, out interfaceMissing);
            if (toImplement.Count == 0)
                continue;

            IsInterfaceMemberMissing = true;
        }
    }
}

现在我们必须读取所有文件，解析它们，并以以下方式调用上述类：

var solutionFiles = new List<FileInfo>();
var trees = new Dictionary<FileInfo, SyntaxTree>();
IProjectContent projectContent = new CSharpProjectContent();
foreach (var file in solutionFiles.Where(f => f.Extension == ".cs").Distinct())
{
    var parser = new ICSharpCode.NRefactory.CSharp.CSharpParser();
    SyntaxTree syntaxTree;
    using (var fs = new FileStream(file.FullName, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan))
    {
        syntaxTree = parser.Parse(fs, file.FullName);
    }
    trees.Add(file, syntaxTree);
    var unresolvedFile = syntaxTree.ToTypeSystem();
    projectContent = projectContent.AddOrUpdateFiles(unresolvedFile);
}
var compilation = projectContent.CreateCompilation();

foreach (var sharpFile in trees)
{
    var originalResolver = new CSharpAstResolver(compilation, sharpFile.Value, sharpFile.Value.ToTypeSystem());
    var visitor = new MissingInterfaceMemberImplementationVisitor(originalResolver);
    sharpFile.Value.AcceptVisitor(visitor);
    if (visitor.IsInterfaceMemberMissing)
       return false;
    }
return true;

var solutionFiles=new List（）；
var trees=newdictionary（）；
IProjectContent projectContent=new CSharpProjectContent（）；
foreach（solutionFiles.Where（f=>f.Extension==“.cs”）.Distinct（）中的var文件）
{
var parser=new ICSharpCode.NRefactory.CSharp.CSharpParser（）；
合成树；
使用（var fs=new FileStream（file.FullName，FileMode.Open，FileAccess.Read，FileShare.Read，4096，FileOptions.SequentialScan））
{
syntaxTree=parser.Parse（fs，file.FullName）；
}
添加（文件，语法树）；
var unsolvedfile=syntaxTree.ToTypeSystem（）；
projectContent=projectContent.AddOrUpdateFiles（unsolvedfile）；
}
var compilation=projectContent.CreateCompilation（）；
foreach（树中的文件）
{
var originalResolver=new CSharpAstResolver（编译，sharpFile.Value，sharpFile.Value.ToTypeSystem（））；
var visitor=新的MissingInterfaceMemberImplementationVisitor（原始解析程序）；
sharpFile.Value.AcceptVisitor（visitor）；
if（visitor.IsInterfaceMemberMissing）
返回false；
}
返回true；
这不是答案。我必须为源代码而不是编译版本做这件事。在你的例子中，如果类测试没有实现接口，它就不会编译，因为我不想编译它。我想用NRefactory检查一下。这不是答案。我必须为源代码而不是编译版本做这件事。在你的例子中，如果类测试没有实现接口，它就不会编译，因为我不想编译它。我想用工厂检查一下。