.NET / CLR의 API 버전 관리, 특히 API 변경으로 인해 클라이언트 응용 프로그램이 중단되는 방법에 관한 정보를 최대한 많이 수집하고 싶습니다. 먼저 몇 가지 용어를 정의하겠습니다.

API 변경 -공개 멤버를 포함한 유형의 공개적으로 정의 된 정의의 변경. 여기에는 유형 및 멤버 이름 변경, 유형의 기본 유형 변경, 구현 된 유형의 인터페이스 목록에서 인터페이스 추가 / 제거, 멤버 추가 / 제거 (오버로드 포함), 멤버 가시성 변경, 메소드 이름 변경 및 유형 매개 변수, 기본값 추가가 포함됩니다. 메소드 매개 변수, 유형 및 멤버에 속성 추가 / 제거 및 유형 및 멤버에 일반 유형 매개 변수 추가 / 제거 (아무것도 놓쳤습니까?) 여기에는 회원 기관의 변경 사항이나 개인 회원의 변경 사항이 포함되지 않습니다 (즉, 우리는 반영을 고려하지 않습니다).

이진 수준 중단 -이전 버전의 API에 대해 클라이언트 어셈블리가 컴파일되어 잠재적으로 새 버전으로로드되지 않는 API 변경입니다. 예 : 이전과 같은 방법으로 호출 할 수있는 경우에도 메소드 서명 변경 (예 : 유형 / 매개 변수 기본값 오버로드를 리턴하는 void)

소스 레벨 중단 -기존 버전의 API를 컴파일하기 위해 작성된 기존 코드가 새 버전으로 컴파일되지 않을 수있는 API 변경입니다. 그러나 이미 컴파일 된 클라이언트 어셈블리는 이전과 같이 작동합니다. 예 : 새로운 오버로드를 추가하여 이전에 모호하지 않은 메소드 호출이 모호해질 수 있습니다.

소스 레벨 자동 의미 변경 -이전 버전의 API에 대해 컴파일하기 위해 작성된 기존 코드로 인해 의미가 자동으로 변경 되는 API 변경 (예 : 다른 메소드 호출). 그러나 코드는 경고 / 오류없이 계속 컴파일되어야하며 이전에 컴파일 된 어셈블리는 이전과 같이 작동해야합니다. 예 : 기존 클래스에서 새 인터페이스를 구현하여 과부하 해결 중에 다른 과부하가 선택되었습니다.

궁극적 인 목표는 가능한 많은 중단 및 조용한 의미 론적 API 변경 사항을 카탈로그 화하고, 중단의 정확한 영향과 그 영향을받는 언어 및 언어를 설명하는 것입니다. 후자를 확장하기 위해 : 일부 변경 사항은 모든 언어에 보편적으로 영향을 미치지 만 (예 : 인터페이스에 새 멤버를 추가하면 모든 언어에서 해당 인터페이스의 구현이 중단 될 수 있음), 일부는 휴식을 취하기 위해 매우 구체적인 언어 의미론이 필요합니다. 여기에는 일반적으로 메서드 오버로드가 포함되며 일반적으로 암시 적 형식 변환과 관련된 모든 작업이 필요합니다. CLS 호환 언어 (예 : CLI 사양에 정의 된대로 “CLS 소비자”의 규칙을 준수하는 언어)에 대해서도 “최소 공통 분모”를 정의 할 수있는 방법이 없습니다. 누군가가 나를 잘못 여기로 고치면 감사하겠습니다. 그래서 언어별로 언어를 이동해야합니다. 가장 관심있는 것은 당연히 .NET과 함께 제공되는 것들입니다. C #, VB 및 F #; IronPython, IronRuby, Delphi Prism 등과 같은 다른 것들도 관련이 있습니다. 코너 케이스가 많을수록 멤버를 제거하는 것과 같은 일이 자명하지만 방법 오버로드, 선택적 / 기본 매개 변수, 람다 형식 유추 및 변환 연산자 간의 미묘한 상호 작용은 매우 놀랍습니다. 때때로.

이것을 시작하는 몇 가지 예 :

새로운 메소드 오버로드 추가

종류 : 소스 수준의 휴식

영향을받는 언어 : C #, VB, F #

변경 전 API :

public class Foo
{
    public void Bar(IEnumerable x);
}

변경 후 API :

public class Foo
{
    public void Bar(IEnumerable x);
    public void Bar(ICloneable x);
}

변경 전에 작동하고 그 후에 깨진 샘플 클라이언트 코드 :

new Foo().Bar(new int[0]);

새로운 암시 적 변환 연산자 오버로드 추가

종류 : 소스 수준의 휴식.

영향을받는 언어 : C #, VB

영향을받지 않는 언어 : F #

변경 전 API :

public class Foo
{
    public static implicit operator int ();
}

변경 후 API :

public class Foo
{
    public static implicit operator int ();
    public static implicit operator float ();
}

변경 전에 작동하고 그 후에 깨진 샘플 클라이언트 코드 :

void Bar(int x);
void Bar(float x);
Bar(new Foo());

참고 : F #은 오버로드 된 연산자에 대한 언어 수준의 지원이 없으므로 명시 적이든 암시 적이든 아니므로 직접적으로 op_Explicit및 op_Implicit메서드를 호출해야하기 때문에 F #은 손상되지 않습니다 .

새로운 인스턴스 메소드 추가

종류 : 소스 수준의 조용한 의미 체계 변경.

영향을받는 언어 : C #, VB

영향을받지 않는 언어 : F #

변경 전 API :

public class Foo
{
}

변경 후 API :

public class Foo
{
    public void Bar();
}

조용한 의미 체계 변경이 발생하는 샘플 클라이언트 코드 :

public static class FooExtensions
{
    public void Bar(this Foo foo);
}

new Foo().Bar();

참고 : F #은 언어 수준을 지원하지 않으므로 ExtensionMethodAttributeCLS 확장 메소드를 정적 메소드로 호출해야 하므로 깨지지 않습니다 .

답변

public static class Foo
{
    public static void bar(int i);
}

public static class Foo
{
    public static bool bar(int i);
}

Foo.bar(13);

public void Foo(int a) { }

public void Foo(int a, string b = null) { }

Foo(5);

class Foo
{
    public virtual void Bar() {}
    public virtual void Baz() {}
}

class FooBase
{
    public virtual void Bar() {}
}

class Foo : FooBase
{
    public virtual void Baz() {}
}

// C++/CLI
ref class Derived : Foo
{
   public virtual void Baz() {{

   // Explicit override    
   public virtual void BarOverride() = Foo::Bar {}
};

interface IFoo
{
    void Bar();
    void Baz();
}

interface IFooBase
{
    void Bar();
}

interface IFoo : IFooBase
{
    void Baz();
}

class Foo : IFoo
{
   void IFoo.Bar() { ... }
   void IFoo.Baz() { ... }
}

(new Foo()).Bar();

public enum Foo
{
   Bar,
   Baz
}

public enum Foo
{
   Baz,
   Bar
}

Foo.Bar < Foo.Baz

public class Foo
{
}

public class Foo
{
    public void Frob() {}
}

class Bar
{
    public void Frob() {}
}

class Program
{
    static void Qux(Action<Foo> a)
    {
    }

    static void Qux(Action<Bar> a)
    {
    }

    static void Main()
    {
        Qux(x => x.Frob());
    }
}

public class Foo : IEnumerable
{
    public IEnumerator GetEnumerator();
}

public class Foo : IEnumerable
{
    IEnumerator IEnumerable.GetEnumerator();
}

new Foo().GetEnumerator(); // fails because GetEnumerator() is no longer public