ASP.NETCORE（C#）与SpringBootMVC(JAVA)干货分享：ASP.NETCORE（C#）与SpringBootMVC ...

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› ASP.NET›ASP.NET编程经验

原作者: [db:作者] 来自: [db:来源] 收藏邀请

我(梦在旅途，http://zuowj.cnblogs.com; http://www.zuowenjun.cn)最近发表的一篇文章《.NET CORE与Spring Boot编写控制台程序应有的优雅姿势》看到都上48小时阅读排行榜（当然之前发表的文章也有哦！），说明关注.NET CORE及Spring Boot的人很多，也是目前的主流方向，于是我便决定系统性的总结一下C# 与JAVA 、ASP.NET CORE 与 Spring Boot MVC，让更多的人了解它们，消除之前可能存在的对.NET或JAVA的误解。

本文目的是通过全面简述C# 与JAVA 在基础语法以及ASP.NET CORE 与 Spring Boot MVC的在框架规范、部署、运行的异曲同工的实现方式，让大家更多的了解C#与JAVA，本文不会刻意说哪门语言好，我认为这是没有意义的，更多的是了解每种语言的特点、优点以及不同语言的共性，掌握编程内功（如：面向对象、DI、AOP、设计模式、算法），这样才能让自己更能适应社会及未来的变化。

本文主要以示例代码为主，辅以简单文字说明，不会细讲每个语法点，只会体现不同的实现方式而矣，全文无废话，全是干货，慢慢欣赏吧。

（注：本文内容是使用Markdown编辑器进行编辑完成！）

C# VS JAVA 基础语法类比篇：

一、匿名类

C#（直接new{}，在{}中直接定义只读公开属性或委托方法，无需预先定义任何接口或类）

            #region 1.匿名类
            var helloWord = new
            {
                CodeBy = "C#匿名类",
                Output = new Action<string, string>((name, codeBy) =>
                {
                    System.Console.WriteLine($"Welcome:{name},Hello Word!  by {codeBy}");
                })
            };

            helloWord.Output("梦在旅途", helloWord.CodeBy);
            #endregion

JAVA（需要先定义接口或类，然后 new 接口或类的构造函数{}，{}内实现接口方法或重写父类接口）

        //1.匿名类
        IHelloWord helloWord=new IHelloWord() {
            @Override
            public void output(String name) {
                System.out.printf("Welcome:%s,Hello Word!  by %s\n",name,getCodeBy());
            }

            @Override
            public String getCodeBy() {
                return "JAVA匿名类";
            }
        };

        helloWord.output("梦在旅途");


public interface IHelloWord {
    void output(String name);
    String getCodeBy();
}

二、类型初始化

C#（IList类型（Dictionary、List）直接在new 类型{}，在{}内直接使用{key,value}或{value}方式添加集合元素，其实是隐式调用了add方法）

            #region 2.类型初始化

            Dictionary<string, string> map = new Dictionary<string, string>
            {
              { "key1","value1" },//(隐式自动调用add方法)
              { "key2", "value2" },
              { "key3", "value3" }
            };

            foreach (var item in map)
            {
                System.Console.WriteLine($"key:{item.Key},value:{item.Value}");
            }

            List<string> list = new List<string>
            {
                "list-item1",//(隐式自动调用add方法)
                "list-item2",
                "list-item3"
            };

            foreach (string item in list)
            {
                System.Console.WriteLine(item);
            }

            String[] strArr = { "arr1", "arr2", "arr3" };
            foreach (string item in strArr)
            {
                System.Console.WriteLine(item);
            }


            Person person = new Person
            {
                Name = "梦在旅途",
                Age = 23,
                Sex = "男"
            };


            string json = JsonConvert.SerializeObject(person);
            System.Console.WriteLine("Person json：" + json);

            #endregion

JAVA（new集合类型{}，并在{}内再次使用{}，即{{赋值 }}，在双大括号内进行赋值操作，省略类名，这个特点有点类似VB及VB.NET的with语句，大家有兴趣可以了解一下，数组的初始化与C#相同，都可以直接在定义数组的时候在{}中给定元素）

        //2.类型初始化
        Map<String,String> map=new HashMap(){
            {
                put("key1","value1");
                put("key2","value2");
                put("key3","value3");
            }
        };

        for (Map.Entry<String, String> item:map.entrySet()) {
            System.out.printf("key:%1$s,value:%2$s\n",item.getKey(),item.getValue());
        }

        List<String> list=new ArrayList(){
            {
                add("list-item1");
                add("list-item2");
                add("list-item3");
            }
        };

        for (String item :list) {
            System.out.printf("%s\n",item);
        }



        String[] strArr={"arr1","arr2","arr3"};

        for (String item :strArr) {
            System.out.printf("%s\n",item);
        }


        Person person=new Person(){
            {
                setName("zwj");
                setAge(32);
                setSex("男");
            }
        };

        ObjectMapper jsonMapper=new ObjectMapper();
        String json= jsonMapper.writeValueAsString(person);
        System.out.println("Person json：" + json);

三、委托（方法引用）

C#（委托定义使用delegate关键字，后面就跟方法答名定义【不含方法体】，可委托普通方法，静态方法，有很多的现成的预定义委托类型，如：Action<T0...T16>,Func<T0...T16,TOut>各有16个重载）

            #region 3.委托
            delegate void HelloDelegate(string name);//定义委托类型(重点是方法签名)

            //常规普通自定义委托类型及委托相应的方法
            HelloWord helloWordObj = new HelloWord();

            HelloDelegate helloDelegate = helloWordObj.Output; //委托实例方法
            helloDelegate.Invoke("梦在旅途");// OR helloDelegate("梦在旅途");

            HelloDelegate helloDelegate2 = HelloWord.OutputForStatic; //委托类的静态方法
            helloDelegate2.Invoke("zuowenjun"); // OR helloDelegate2("zuowenjun");

            //使用通用的已封装好的委托类型（如：Func、Action）并实例化
            Func<int, int, int> multiplyFunc = new Func<int, int, int>(delegate (int a, int b)
            {
                return a * b;
            });

            int x = 12, y = 25;
            int multiplyResult = multiplyFunc.Invoke(x, y); //OR multiplyFunc(x,y);
            System.Console.WriteLine($"{x}乘以{y}等于:{multiplyResult}");

            Action<string> helloAction = new Action<string>(delegate (string name)
            {
                System.Console.WriteLine($"hello,{name},how are you!");
                System.Console.WriteLine("learning keep moving!");
            });
            helloAction.Invoke("www.zuowenjun.cn");

            #endregion

JAVA（定义委托需要先定义委托类型【即：函数式接口，规则：接口+@FunctionalInterface+一个方法定义】，然后就可以普通方法，静态方法，有很多的现成的预定义委托类型【即：函数式接口】，如：BiFunction，Consumer等）

        //3.委托

        HelloWord helloWordObj = new HelloWord();

        HelloWordDelegate helloWordDelegate = helloWordObj::output;
        helloWordDelegate.invoke("梦在旅途");

        HelloWordDelegate helloWordDelegate2 = HelloWord::outputForStatic;
        helloWordDelegate2.invoke("zuowenjun");


        //使用已封装好的委托方法（JAVA这边称：函数式接口，有很多详见：https://www.runoob.com/java/java8-functional-interfaces.html）
        BiFunction<Integer, Integer, Integer> multiplyFunc = new BiFunction<Integer, Integer, Integer>() {
            @Override
            public Integer apply(Integer i, Integer i2) {
                return i * i2;
            }
        };

        int x = 12, y = 25;
        int multiplyResult = multiplyFunc.apply(x, y);
        System.out.printf("%d乘以%d等于:%d%n", x, y, multiplyResult);


        Consumer<String> helloAction=new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.printf("hello,%s,how are you!%n",s);
                System.out.printf("learning keep moving!%n");
            }
        };
        helloAction.accept("www.zuowenjun.cn");


@FunctionalInterface
public interface HelloWordDelegate {
    void  invoke(String name);
}

public class HelloWord implements IHelloWord {

    @Override
    public void output(String name) {
        System.out.printf("Welcome:%s,Hello Word!  by %s\n",name,getCodeBy());
    }

    public  static void outputForStatic(String name){
        System.out.printf("Welcome:%s,Hello Word!  by JAVA static\n",name);
    }

    @Override
    public String getCodeBy() {
        return "JAVA";
    }
}

四、Lambda表达式

C#（使用(入参)=>{方法处理体}，与要传入或要实例化的委托方法签名相同即可）

            #region 4.Lambda

            Func<int, int, int> multiplyFunc2 = new Func<int, int, int>((a, b) => a * b);

            int x2 = 12, y2 = 25;
            int multiplyResult2 = multiplyFunc2.Invoke(x2, y2); //OR multiplyFunc(x,y);
            System.Console.WriteLine($"{x2}乘以{y2}等于:{multiplyResult2}");

            Action<string> helloAction2 = new Action<string>(name =>
            {
                System.Console.WriteLine($"hello,{name},how are you!");
                System.Console.WriteLine("learning keep moving!");
            });

            helloAction2.Invoke("www.zuowenjun.cn");

            int[] intArr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            intArr = intArr.Where(i => i >= 5).ToArray();
            foreach (int i in intArr)
            {
                System.Console.WriteLine($"int-{i}");
            }

            string msg = "测试外部变量被Lambda引用";
            Action testMsgAction = () =>
            {
                msg += "--改变内容";
                System.Console.WriteLine("Lambda方法体中的值：" + msg);
            };
            testMsgAction();
            System.Console.WriteLine("原始值：" + msg);

            #endregion

注意与C#不同，Lambda方法体内不能引用外部非final的变量，与C# Lambda有本质不同）

        //4.Lambda

        BiFunction<Integer, Integer, Integer> multiplyFunc = (i1, i2) -> i1 * i2;

        int x = 12, y = 25;
        int multiplyResult = multiplyFunc.apply(x, y);
        System.out.printf("%d乘以%d等于:%d%n", x, y, multiplyResult);


        Consumer<String> helloAction= s -> {
            System.out.printf("hello,%s,how are you!%n",s);
            System.out.printf("learning keep moving!%n");
        };
        helloAction.accept("www.zuowenjun.cn");

        int[] intArr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        intArr= Arrays.stream(intArr).filter(value -> value>=5).toArray();
        for (int n : intArr) {
            System.out.printf("int-%d%n",n);
        }

五、泛型

C#（真泛型，不同的泛型类型参数视为不同的类型，有泛型接口，泛型类，泛型方法，泛型委托，泛型约束：in表示逆变【泛型参数父类型转子类型，属于消费者，一般用于入参】，out 表示协变【泛型参数子类型转父类型】，只有委托、接口才支持可变性）

            #region 5.泛型

            //常用泛型集合类型
            List<int> intList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

            List<long> longList = new List<long> { 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L };

            Dictionary<string, string> dic = new Dictionary<string, string> {
                { "k1","v1"},{ "k2","v2"},{ "k3","v3"}
            };

            //泛型方法
            var demo = new DemoGenericClass();
            //demo.DisplayResult("学习永无止境"); 错误，因为约束是值类型
            demo.DisplayResult(ConsoleColor.DarkGreen);

            List<YellowPerson> yellowPersonList = new List<YellowPerson> {
                new YellowPerson(){ Name="zzz",Age=11,Sex="G"},
                new YellowPerson(){ Name="xxx",Age=22,Sex="B"}
            };

            //协变(泛型参数子类转父类)
            //public interface IEnumerable<out T>
            IEnumerable<YellowPerson> yellowPersons = yellowPersonList;
            IEnumerable<Person> persons = yellowPersons;//协变（子类到父类的转变） ,泛型参数 out标记，一般用于出参,这个正确的

            // List<Person> personList = yellowPersonList; 因为List是类，而且泛型参数并没有标记out，不适用协变，故这样转换是错误的

            foreach (var p in persons)
            {
                System.Console.WriteLine($"item :【Name={p.Name},Age={p.Age},Sex={p.Sex},Color={p.Color}】");
            }

            //逆变（泛型参数父类转子类）
            Action<object, object> showPlusResultAction = (d1, d2) => Console.WriteLine($"{d1}+{d2}={d1.ToString() + d2.ToString()}");

            Action<string, string> showStrPlusResultAction = showPlusResultAction;//逆变（父类到子类的转变），泛型参数 in标记，一般用于入参

            showPlusResultAction(55, 66);
            showStrPlusResultAction("你好", "中国");

            ShowMsg<Person> showMsg = new ShowMsg<Person>((p) =>
            {
                System.Console.WriteLine($"ShowMsg :【Name={p.Name},Age={p.Age},Sex={p.Sex},Color={p.Color}】");
            });
            //ShowMsg<HelloWord> showMsg2 = new ShowMsg<HelloWord>(...); 这样是不行的，因为泛型约束为需继承自Person

            showMsg.Invoke(new Person() { Name = "zuowenjun", Age = 33, Sex = "B" });
            showMsg.Invoke(new YellowPerson() { Name = "zuowenjun2", Age = 33, Sex = "B" });

            //综合演示：入参逆变，出参协变
            Func<Person, Person, string> getDataFunc = (x, y) => x.Name + y.Name;
            Func<YellowPerson, YellowPerson, object> getDataFunc2 = getDataFunc;
            object dataResult = getDataFunc2(new YellowPerson() { Name = "张三", Age = 33, Sex = "G" }, new YellowPerson() { Name = "赵六", Age = 33, Sex = "B" });
            System.Console.WriteLine($"getDataFunc2:{dataResult}");

            List<int> a = new List<int>();
            List<String> b = new List<string>();
            bool isEqual = (a.GetType() == b.GetType());
            System.Console.WriteLine($"List<int> 与 List<String> {(isEqual ? "is" : "not")} Equal ");//结果是不相等


            #endregion
   
   //以上示例需要用到的类
   
   public class BaseClass
    {
        /// <summary>
        /// 必需是用virtual标记的方法（即：虚方法）或abstract标记的方法（即：抽象方法）子类才能使用override进行重写
        /// </summary>
        /// <param name="name"></param>
        public virtual void SayHello(string name)
        {
            System.Console.WriteLine($"{nameof(BaseClass)} Say:{name},hello!");
        }
        
    }
   
            
    public class DemoGenericClass : BaseClass, IDisposable
    {
        public void DisplayResult<T>(T arg) where T : struct
        {
            System.Console.WriteLine($"DemoGenericClass.DisplayResult:{arg}");
        }

        public void Dispose()
        {
            System.Console.WriteLine("DemoGenericClass Disposed");
        }

        public override void SayHello(string name)
        {
            base.SayHello(name);
            System.Console.WriteLine($"{nameof(DemoGenericClass)} Say:{name},hello again!");
        }
    }
    

    public class Person
    {
        public virtual Color Color { get; }
        public string Name { get; set; }

        public int Age { get; set; }

        public string Sex { get; set; }

    }

    public class BlackPerson : Person
    {
        public override Color Color => Color.Black;
    }

    public class YellowPerson : Person
    {
        public override Color Color => Color.Yellow;
    }

    public class WhitePerson : Person
    {
        public override Color Color => Color.White;
    }

JAVA（伪泛型，编译后类型参数擦除，同一个泛型类型不同的泛型参数类型相同，有泛型接口，泛型类，泛型方法，泛型约束：super限定下边界，逆变，用于入参,属于消费者,extends限定上边界，协变，用于出参,属于生产者，还有？通匹符）

      //常用泛型集合
        List<Integer> intList = new ArrayList(){
            {
                add(1);
                add(2);
                add(3);
                add(4);
                add(5);
            }
        };

        Map<String,String> map=new HashMap(){
            {
                put("k1","v1");
                put("k2","v2");
                put("k3","v3");
            }
        };

        //泛型方法
        DemoGenericClass demo=new DemoGenericClass();
        demo.displayResult(new YellowPerson(){{
            setName("zwj");setSex("B");setAge(33);
        }});

        List<Integer> a=new ArrayList<>();
        List<String> b=new ArrayList<>();
        boolean isEqual =(a.getClass()==b.getClass());
        System.out.printf("List<Integer>与List<String> %s Equal %n",isEqual?"is":"not"); //结果是相等，都是同一个List类型，不能使用instanceof判断泛型类型实例

        //协变、逆变（详见说明：https://www.jianshu.com/p/2bf15c5265c5 ，意义与C#相同）
        List<? super Person> persons=new ArrayList<>(); //super：限定下边界，逆变，用于入参
        persons.add(new Person(){
            {
                setName("张三");
                setAge(25);
                setSex("B");
            }
        });

        persons.add(new YellowPerson(){
            {
                setName("赵六");
                setAge(18);
                setSex("G");
            }
        });

       List<? extends Person> result= (List<? extends Person>) persons;//extends:限定上边界，协变，用于出参
       for (Person p:result){
           System.out.printf("Person list item:%s %n",p.toString());
       }

//以上示例需要用到的类
    public class DemoGenericClass implements AutoCloseable
    {
        @Override
        public void close() throws Exception {
            System.out.println("DemoGenericClass closed");
        }

        public <T extends Person> void displayResult(T arg) //泛型约束（泛型参数上边界,协变）
        {
           System.out.printf("DemoGenericClass.DisplayResult:%s %n",arg.toString());
        }
    }
    

public class Person {
    private String name;
    private int age;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return String.format("Person=[Name:%s,Age:%d,Sex:%s] %n", name, age, sex);
    }
}

class YellowPerson extends Person {

    @Override
    public String toString() {
        return "YellowPerson#toString-"+ super.toString();
    }
}

六、自动释放

C#（采用using包裹，要实现自动释放必需实现IDisposable接口）

            using (var demo2 = new DemoGenericClass()) //DemoGenericClass实现IDisposable接口
            {
                demo2.DisplayResult(123456);
            }

JAVA（采用try包裹，要实现自动释放必需实现AutoCloseable接口）

        try(DemoGenericClass demo=new DemoGenericClass()) {
            demo.displayResult(new YellowPerson(){
                {
                    setName("zuowenjun");
                    setAge(33);
                    setSex("B");
                }
            });
        }

七、重写（override）

C#（必需是用virtual标记的方法（即：虚方法）或abstract标记的方法（即：抽象方法）子类才能使用override进行重写，重写后父类的方法将被子类取代，若需在子类中执行父类被重写的方法，应使用base关键字，若父类方法非虚方法或抽象方法但又想“重写”怎么办？则只能使用new覆盖方法，覆盖方法与重写方法的不同之处在于，在父类中仍可以正常执行父类的方法而不会执行子类的覆盖方法，覆盖方法的方法签名、访问修饰符均没有严格限制，即使不相同仍不会报错，但IDE会有提示，如需真正覆盖父类方法，则应按照重写的规范来，只是使用new来修饰覆盖方法，但覆盖方法与重写方法有本质不同，一般情况下更建议使用重写方法）

C#所有类的普通方法默认是密封方法（类似JAVA的final方法），是不允许被重写，可以理解为默认是不开放的，需要开放重写的方法必需使用virtual标记为虚方法（虚方法至少是protected及以上的访问权限），若重写后不想被后续的子类再次重写，则可以标记为sealed，即：密封方法

    public class BaseClass
    {
        /// <summary>
        /// 必需是用virtual标记的方法（即：虚方法）或abstract标记的方法（即：抽象方法）子类才能使用override进行重写
        /// </summary>
        /// <param name="name"></param>
        public virtual void SayHello(string name)
        {
            System.Console.WriteLine($"{nameof(BaseClass)} Say:{name},hello!");
        }
        
    }

    public class DemoGenericClass : BaseClass
    {
        public override void SayHello(string name)
        {
            base.SayHello(name);
            System.Console.WriteLine($"{nameof(DemoGenericClass)} Say:{name},hello again!");
        }
    }

JAVA（非private 且非 final 修饰的普通方法默认均可在子类中进行重写，重写要求基本与C#相同，只是无需强制Override关键字，但建议仍使用@Override注解，以便IDE进行重写规范检查，重写后父类的方法将被子类取代，若需在子类中执行父类被重写的方法，应使用super关键字）

JAVA所有类的普通方法默认是虚方法，都是可以被重写，可以理解为默认是开放重写的，若不想被重写则应标记为final ,即：最终方法（C#中称密封方法）

    public  class BaseClass{
        public  void  testOutput(String msg){
            System.out.println("output Msg:" + msg);
        }
    }

    public class DemoGenericClass extends BaseClass
    {
        @Override
        public  void  testOutput(String msg){
            super.testOutput(msg);
            System.out.println("output again Msg:" + msg);
        }
    }

ASP.NET CORE VS Spring Boot 框架部署类比篇：

一、引用依赖（包）

C#（编辑csproj文件，可以通过PackageReference引用包、ProjectReference引用同一个解决方案下的其它项目，Reference引用本地DLL组件，csproj除了引用包以外，还可以通过在PropertyGroup元素下配置相关的属性，比如TargetFramework指定SDK框架版本等）

.NET项目的包是NuGet包，可以从nuget.org上查找浏览所需的包，项目中引用依赖包，除了在csproj文件中使用PackageReference添加编辑外（具体用法参见：项目文件中的包引用 (PackageReference)）还可以使用package manager控制台使用包管理命令，如：Install-Package ExcelEasyUtil -Version 1.0.0，或者直接使用.NET CLI命令行工具，如：dotnet add package ExcelEasyUtil --version 1.0.0

.NET有包、元包、框架之分，详细了解：包、元包和框架

  <!--包引用-->
  <ItemGroup>
    <PackageReference Include="Autofac.Extras.DynamicProxy" Version="4.5.0" />
    <PackageReference Include="Autofac" Version="4.9.2" />
    <PackageReference Include="Microsoft.AspNetCore.App" />
    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.1.1" />
    <PackageReference Include="Autofac.Extensions.DependencyInjection" Version="4.4.0" />
  </ItemGroup>

  <!--同一解方案下的项目引用-->
  <ItemGroup>
    <ProjectReference Include="..\StandardClassLib2019\StandardClassLib2019.csproj"  />
  </ItemGroup>

  <!--本地组件直接引用-->
  <ItemGroup>
    <Reference Include="KYExpress.Common">
      <HintPath>xxxx\xxxx.dll</HintPath>
      <Private>true</Private>
    </Reference>
  </ItemGroup>

JAVA（编辑POM 文件，通过dependencies.dependency来声明引入多个依赖，根据scope可以指定依赖的有效作用范围）

    <dependencies>
        <!--maven包依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!--本地JAR包依赖（scope=system,systemPath=jar包存放目录）-->
        <dependency>
            <groupId>cn.zuowenjun.boot.mybatis.plugin</groupId>
            <artifactId>cn.zuowenjun.boot.mybatis.plugin</artifactId>
            <version>1.0</version>
            <scope>system</scope>
            <systemPath>${basedir}/src/main/libs/xxxxx.jar</systemPath>
        </dependency>

        <!--同一父项目Module之间依赖,注意这个必需先创建基于POM的父项目，然后各子Moudle 的POM 的parent指向父项目-->
        <dependency>
            <groupId>cn.zuowenjun.springboot</groupId>
            <artifactId>springboot-demo1</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

JAVA POM 依赖继承两种方式

通过parent继承，如下所示：(如下是非常典型的spring boot的parent继承)，项目将继承spring-boot-starter-parent POM中的所有设置及依赖（如：properties、dependencies等）

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
    </parent>

通过dependencyManagement继承，如下所示：（这是依赖管理，dependencyManagement里只是声明依赖，并不实现引入，因此子项目可按需显式的声明所需的依赖项。如果不在子项目中声明依赖，则不会从父项目中继承依赖，只有在子项目中声明了依赖项，且没有指定具体版本，才会从父项目中继承依赖项，（写了版本号相当于覆盖），version和scope都读取自父pom）

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR2</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

二、依赖注入 DI （IOC容器）

在 ASP.NET Core 依赖注入）

//1.使用ASP.NET CORE默认的DI框架，在Startup文件中ConfigureServices方法中按需注册依赖
        public void ConfigureServices(IServiceCollection services)
        {
            //采用ASP.NET CORE默认的IOC容器注册
            services.AddTransient<IOperationTransient, Operation>();
            services.AddScoped<IOperationScoped, Operation>();
            services.AddSingleton<IOperationSingleton, Operation>();
            services.AddSingleton<IOperationSingletonInstance>(new Operation(Guid.Empty));
        }

//2.在Controller中就可以直接采用构造函数注入或指明从IOC容器中获得实例[FromServices]
    [ApiController]
    [Route("api/[controller]")]
    public class DemoController : Controller
    {
        private readonly OperationService operationService;

        public DemoController(OperationService operationService)
        {
            this.operationService = operationService;
        }

        [Route("optid")]
        public object Operation([FromServices]OperationService optSrv){
            //TODO:方法体中直接使用operationService 或 入参optSrv均可
        }
      }

//如上所需接口及类定义

    public interface IOperation
    {
        Guid OperationId { get; }
    }


    public interface IOperationTransient : IOperation
    {
    }

    public interface IOperationScoped : IOperation
    {
    }

    public interface IOperationSingleton : IOperation
    {
    }

    public interface IOperationSingletonInstance : IOperation
    {
    }
    

    public class Operation : IOperationTransient,
        IOperationScoped,
        IOperationSingleton,
        IOperationSingletonInstance
    {
        public Operation() : this(Guid.NewGuid())
        {
        }

        public Operation(Guid id)
        {
            OperationId = id;
        }

        public Guid OperationId { get; private set; }
    }
    
    public class OperationService
    {
        public OperationService(
            IOperationTransient transientOperation,
            IOperationScoped scopedOperation,
            IOperationSingleton singletonOperation,
            IOperationSingletonInstance instanceOperation)
        {
            TransientOperation = transientOperation;
            ScopedOperation = scopedOperation;
            SingletonOperation = singletonOperation;
            SingletonInstanceOperation = instanceOperation;
        }

        public IOperationTransient TransientOperation { get; }