标签: interface

我在类库（项目“A”）上有这个对象，我想在多个项目（“B”和“C”）中使用它：

public class Notification : INotification
{
    public string Id { get; set; }

    public int Type { get; set; }

    public IList<Message> Messages { get; set; }
}

public class Message: IMessage
{
    public string Key { get; set; }

    public string Value { get; set; }

    public string Culture { get; set; }
}

public interface INotification
{
    string Id { get; set; }

    int Type { get; set; }

    IList<Message> Messages { get; set; }
}

现在，如果我想在我的项目“B”上创建这个对象，我需要执行以下操作： …

我有一些遗留代码，如下所示：

    Set<Class<? extends Foo>> classes = reflections.getSubTypesOf(Foo.class);
    for (Class<? extends Foo> cl : classes) {
        Foo<?, ?> foo = cl.newInstance();
        // use foo
    }

我想添加另一个接口：

interface NewFoo extends Foo {...}

但随后它尝试调用 NewFoo 上的 newInstance。目前我的解决方案是这样的：

        try {
            Foo<?, ?> foo = cl.newInstance();
            // use foo
        } catch (InstantiationException ignore) {
        }

但我想知道是否有更好的方法？当我手里有一个Class对象时，我能区分接口和类吗？

当 Javascript 更新一个对象时，就像下面这样。

const data = {
    a: 1,
    b: 3,
    c: 4
}


const update = (summary) => {
  data[summary] += 1;
  console.log(data);

}

update('a');

我用 Typescript 尝试了同样的事情，但它不起作用，因为我知道我做错了什么，有人可以指出错误以及如何解决问题。

interface Summary { 
    a: number,
    b: number,
    c: number
}

const data: Summary = {
    a: 1,
    b: 3,
    c: 4
}


const updateData = (summaryType: string) => { 
    data[summaryType] += 1 // Error
}

错误是 -> 元素隐式具有“any”类型，因为“string”类型的表达式不能用于索引类型“Summary”。在“Summary”类型上找不到带有“string”类型参数的索引签名。(7053)

从服务器接收到的 JSON 结构如下（我更改了详细信息）：

{
  "apple": {
    "fruitName": "apple",
    "types": {
      "greenApple": {
        "productCode": "P1",
        "productName": "Green Apple",
        "color": "green",
      },
      "galaApple": {
        "productCode": "P2",
        "productName": "Gala Apple",
        "color": "light red",
      },
      "redDelicious": {
        "productCode": "P3",
        "productName": "Red delicious apple",
        "color": "bright red",
      }
    }
  },
  "orange": {
    "fruitName": "orange",
    "types": {
      "mandarin": {
        "productCode": "P5",
        "productName": "Mandarin Oranges",
        "color": "orange",
      },
      "bloodOrange": {
        "productCode": "P6",
        "productName": "Blood Orange",
        "color": "red",
      }
    }
  },
}

我正在为我的项目使用 Typescript 设计一个接口结构。

到目前为止我已经想出了这个：

export type …

我正在对纵梁进行这个练习。

问题：使IPAddr类型实现fmt.Stringer将地址打印为点线四边形。例如，IPAddr{1, 2, 3, 4}应打印为"1.2.3.4".

起始代码：

package main

import "fmt"

type IPAddr [4]byte

// TODO: Add a "String() string" method to IPAddr.

func main() {
    hosts := map[string]IPAddr{
        "loopback":  {127, 0, 0, 1},
        "googleDNS": {8, 8, 8, 8},
    }
    for name, ip := range hosts {
        fmt.Printf("%v: %v\n", name, ip)
    }
}

这是我的代码：

func (addr IPAddr) String() string {
    return fmt.Sprintf("%v.%v.%v.%v", addr[0], addr[1], addr[2], addr[3])
}

它成功了！但我不明白为什么。我发现我不必显式定义Stringer接口，因为它包含在 中 …

您经常听说接口中的方法没有实现。然而，在 Java 8 中，可以实现默认方法。但我很感兴趣。是否可以本地实现接口方法？（native方法）。

当面试问题被问到“是否可以在接口中实现方法？” 答案 - 您可以实现本机方法，并且从 Java 8 开始可以定义默认方法。” 这个答案正确吗？

这是一个重大的界面更改吗？如果是这样，为什么？（这不是家庭作业，只是为了确保其他客户不会因这一变化而受到影响）

当前接口：

public interface MyInterface
{
     IPropertyInterfaceOld Propery1 {get; set;}
}

public interface IPropertyInterfaceOld
{
}

建议的接口：

public interface MyInterface
{
     IPropertyInterfaceNew  Propery1 {get; set;}
}

public interface IPropertyInterfaceOld
{
}

public interface IPropertyInterfaceNew : IPropertyInterfaceOld
{
}

我正在测试java的lambda是否与接口函数匹配，我在下面编写了代码，它可以工作。我有界面MyHandler，及其myFunction。在构造时，Java lambda 被转换为我的接口的实现者。

package mygroup;
interface MyHandler{
    void myFunction(int i);
}
class Worker{
    private final MyHandler handler;
    public Worker(MyHandler h){
        handler = h;
    }
    public void work(int i){handler.myFunction(i);};
}
public class TestLambda {
    public static void main(String[] args) {
        Worker worker = new Worker(i -> System.out.println(i));
        worker.work(3);
    }
}

程序将打印3. 到目前为止一切顺利，但如果我添加一些其他函数声明，MyHandler如下所示：

interface MyHandler{
    void myFunction(int i);
    void f(int i, int j);
}

Thread 构造函数中的 lambda 将无法编译，表示

The constructor Worker((<no type> i) -> …

我想将 a 注入IDictionary到{key, interface}构造函数中，但我不知道如何在构造函数中设置它program.cs

我可以启动接口，也可以启动接口IDictionary，但我不知道如何组合它们。

任何建议都会被采纳。

附加背景：

所以我需要注入我的服务，例如

我需要注入服务，例如，

s.AddTransient<IFooService, AFooService>();
s.AddTransient<IFooService, BFooService>();

但在我想要的构造函数中

public MyClass(IDictionary<string, IFooService> fooServices)

这是枚举：

enum PossibleValues {
  A = 'A',
  B = 'B',
  C = 'C'
}

这是使用枚举作为字段之一的类型：

export interface MyInterface {
  name: string;
  age: number;
  value: PossibleValues;
}

我假设在这种情况下，因为value它应该只接受来自枚举（A、B 或 C）的值，但我可以放在那里其他值并且它工作正常。

有没有办法将可能的值限制为枚举中的值？