C#和java是什么关系？为什么那么像呢？

Question

我初学c#，但发现C#和java 非常非常相像，我对java还比较了解，是不是意味着C#的80%我就不用学了？

Answer 1

看兴趣。做一个删除，修改，查询再加一个分页 .net bs 1分钟不到搞定
区别就是.net有的功能都分装成控件拉出来用就好了 而java都要手写
当然java也非常好的 不然分方向我也不会不选.net而选java了
什么语言思路都一样 

Answer 2

那是你只知道java、C#，你要是知道其他语言你会发现，都是很相似的，，
相似的只是语法而已，，

Answer 3

你对java比较了解的话，学起C#来更快，都是面向对象语言。

Answer 4

你说的是C# 1.0。C#已经早就和Java不像了。随便贴一个C#代码：你能看懂80%么？
using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Text;namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            MazeModel mm = new MazeModel(7, 5);
            mm.DisplayMaze();
        }
    }    class MazeModel
    {
        private bool[] edges;        public int HorizontalVertex { get; private set; }        public int VerticalVertex { get; private set; }        private bool getEdgeValue(int edgeindex)
        {
            try
            {
                return edges[edgeindex];
            }
            catch
            {
                return false;
            }
        }        private void setEdgeValue(int edgeindex, bool value)
        {
            try
            {
                edges[edgeindex] = value;
            }
            catch { }
        }        private int nodeToEdgeIndex(int x, int y, int dir)
        {
            if (x == 0 && dir == 1) return -1;
            if (x % HorizontalVertex == HorizontalVertex - 1 && dir == 2) return -1;
            if (y == 0 && dir == 0) return -1;
            if (y >= HorizontalVertex * (VerticalVertex - 1) && dir == 3) return -1;            return (y * 2 + ((dir == 1 || dir == 2) ? 0 : (dir == 0 ? -1 : 1))) * HorizontalVertex + x - (dir == 1 ? 1 : 0);
        }        private int nodeindexToEdgeIndex(int nodeindex, int dir)
        {
            int x;
            int y;
            nodeIndexToNode(nodeindex, out x, out y);
            return nodeToEdgeIndex(x, y, dir);
        }        private void nodeIndexToNode(int nodeindex, out int x, out int y)
        {
            x = nodeindex % HorizontalVertex;
            y = nodeindex / HorizontalVertex;
        }        private int nodeToNodeIndex(int x, int y)
        {
            return y * HorizontalVertex + x;
        }        private void edgeIndexToNodeIndex(int edgeindex, out int node1, out int node2)
        {
            int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
            if (edgeindex / HorizontalVertex % 2 != 0)
            {
                x1 = x2 = edgeindex % HorizontalVertex;
                y1 = edgeindex / (HorizontalVertex * 2);
                y2 = y1 + 1;
            }
            else
            {
                x1 = edgeindex % HorizontalVertex;
                x2 = x1 + 1;
                y1 = y2 = edgeindex / (HorizontalVertex * 2);
            }
            node1 = nodeToNodeIndex(x1, y1);
            node2 = nodeToNodeIndex(x2, y2);
        }        private int edgeIndexToNodeIndex(int edgeindex, int node)
        {
            int node1, node2;
            edgeIndexToNodeIndex(edgeindex, out node1, out node2);
            return node1 == node ? node2 : node1;
        }        private IEnumerable<int> getNodeEdges(int nodeIndex, List<int> blocklist)
        {
            return Enumerable
                .Range(0, 4)
                .Select(x => nodeindexToEdgeIndex(nodeIndex, x))
                .Where(x => getEdgeValue(x) && !blocklist.Contains(x));
        }        private void generateMaze()
        {
            List<int> blockEdges = new List<int>();
            while (blockEdges.Count < HorizontalVertex * VerticalVertex - 1)
            {
                var nodes = Enumerable.Range(0, HorizontalVertex * VerticalVertex)
                    .Where(x => getNodeEdges(x, blockEdges).Count() > 1).ToList()
                    .Select(x => new { k = Guid.NewGuid(), v = x })
                    .OrderBy(x => x.k)
                    .Select(x => x.v).ToList();
                if (nodes.Count == 0) return;
                int node = nodes.First();
                var tedges = getNodeEdges(node, blockEdges).ToList()
                    .Select(x => new { k = Guid.NewGuid(), v = x })
                    .OrderBy(x => x.k)
                    .Select(x => x.v).ToList();
                if (tedges.Count == 0) return;
                int edge = tedges.First();
                var edgesbackup = edges.ToArray();
                setEdgeValue(edge, false);
                if (!testMaze())
                {
                    blockEdges.Add(edge);
                    edges = edgesbackup;
                }
            }
        }        private bool testMaze()
        {
            var found = new List<int>() { 0 };
            findNode(0, found);
            return found.Count() == HorizontalVertex * VerticalVertex;
        }        private void findNode(int nodeindex, List<int> found)
        {
            var nextNodes = getNodeEdges(nodeindex, new List<int>())
                .Select(x => edgeIndexToNodeIndex(x, nodeindex))
                .Where(x => !found.Contains(x))
                .ToList();
            foreach (int item in nextNodes)
            {
                found.Add(item);
            }
            foreach (int item in nextNodes)
            {
                findNode(item, found);
            }
        }        public MazeModel(int horizontalvertex, int verticalvertex)
        {
            HorizontalVertex = horizontalvertex;
            VerticalVertex = verticalvertex;
            edges = Enumerable
                .Range(0, horizontalvertex * (verticalvertex * 2 - 1) - 1)
                .Select(x => 
                    x % horizontalvertex != horizontalvertex - 1 ||
                    x / horizontalvertex % 2 != 0
                ).ToArray();
            generateMaze();
        }        public void DisplayMaze()
        {
            for (int i = 0; i < VerticalVertex; i++)
            {
                for (int j = 0; j < HorizontalVertex; j++)
                {
                    Console.Write("X");
                    if (j != HorizontalVertex - 1)
                    {
                        Console.Write(getEdgeValue(nodeToEdgeIndex(j, i, 2)) ? "-" : " ");
                    }
                }
                Console.WriteLine();
                for (int j = 0; j < HorizontalVertex; j++)
                {
                    if (i != VerticalVertex - 1)
                    {
                        Console.Write(getEdgeValue(nodeToEdgeIndex(j, i, 3)) ? "|" : " ");
                        Console.Write(" ");
                    }
                }
                Console.WriteLine();
            }
        }
    }
}

Answer 5

当年我从C++转向C#的时候，也觉得C#里面很多东西和C++很像。都是成熟的面向对象的编程语言，面向对象的思想决定了它们天然有很多相似之处。
但是仔细一用又各有不同，各有天地。

Answer 6

如果是熟悉java的人，能看懂80%也是很正常的！

Answer 7

赞同，我是个JAVA程序员，我都能看懂，但是他用了LINQ，这个是VS2008以上的版本才支持的，2005都没有
也就是.NET3.0而非1.0以上了。
版主不厚道说话没逻辑性。

Answer 8

Microsoft 看 sun 的java 认为是很好的OOP语言，其中的包概念非常好，语言结构比较c++更人性化！其中虚拟机概念很受欢迎！所以microsoft 就 模仿并改良了java 再配合原来IDE的优势经验。弄出了以 VS为IDE，以.net framework 为虚拟机运行框架的 开发语言，c#只是其中一个，还有vb，j#，js等类的。不管.net 下的任何语言，写出的程序最终会被net framework 编译成统一的CLR交由底层处理！

Answer 9

原本微软也是支持java的，后来闹掰了，就自己整了个C#。

Answer 10

我学java的，但出来后做的第一个系统是C#的，没时间学习，把它当java代码写，结果也能运行。
还有ActionScript也跟java，C#很像。