Sử dụng GetType/instanceof trong C# so với các lựa chọn thay thế

Question

Tôi đã gặp một vấn đề trong trò chơi mà tôi đang thực hiện trong C#. Đó là một trò chơi kết hợp dựa trên gạch đơn giản và vấn đề nảy sinh khi tôi cố gắng tạo ra:

Giả sử chúng ta có các loại gạch cơ bản, hình vuông và hình thoi, tất cả đều là lớp con của Ngói. Thay vì có vòng tròn chỉ phù hợp với vòng kết nối, tôi đã cố gắng trích xuất hành vi "đối sánh" thành phương thức Gạch trừu tượng: canMatchWith (Ngói t). Gạch cũng có hai phương pháp để thêm/loại bỏ Gạch mà chúng có thể khớp với.

Vì vậy, hãy nói rằng chúng tôi có một hình tròn ở giữa trò chơi của chúng tôi và chúng tôi có một powerup có nội dung "Gạch tròn có thể khớp với ô vuông lần lượt này". Tôi sẽ đi qua tất cả các gạch Circle và nói circleTile.addCanMatchWith (typeof (Square)). Bên trong, chúng ta có một List canMatchWith.

Sau đó, tôi muốn nói "Vòng kết nối không còn có thể khớp với hình vuông" và chỉ cần nói circleTile.removeCanMatchWith (typeOf (Square)).

Đây là giải pháp hiện tại của tôi và nó hoạt động tuyệt vời không có hiệu suất mà tôi đã nhận thấy (Đó là trò chơi xếp hình dựa trên gạch, vì vậy các loại này chỉ được đánh giá một lần cho mỗi lần di chuyển, chứ không phải khung theo khung). Tuy nhiên, giọng nói trong đầu tôi đang nói với tôi rằng đây là một cách tồi tệ để hoàn thành hành vi này. Vì vậy, tôi có một số lựa chọn thay thế:

1. Enums ... Mỗi ô có thể được tạo với một biến kiểu Tiletype. Điều này sẽ được khởi tạo trong hàm tạo và đặt thành Type.SQUARE cho các ô vuông, v.v. Sau đó, mỗi Tile sẽ có một List canMatchWith, và chức năng giống như việc thực hiện ban đầu của tôi. Ngoại trừ trong trường hợp này, nó phức tạp hơn một chút. Nói rằng tôi có một số lớp con vòng tròn, hình bầu dục và hình elip. Tôi muốn hình bầu dục để có thể phù hợp với hình vuông chỉ, nhưng elipses có thể phù hợp với tất cả các vòng tròn và không vuông.

Vấn đề ở đây là dự phòng, enum của tôi bây giờ sẽ có OVAL và ELIPSE, và lớp Elipse sẽ có (CIRCLE, OVAL, ELIPSE TileTypes) là loại có thể khớp với. Điều này là hoàn toàn dư thừa, tôi muốn chỉ nói "Circle" mà tôi có thể với các loại. Tôi cho rằng các Brick có thể có TileType baseType và TileType actualType.

2. Một số dạng thành phần hành vi. Hãy quên đi các lớp con Tile, chỉ cần đưa ra các phương thức Tiles và một biến cá thể cho List. Sau đó, tại thời gian chạy, chúng tôi chỉ có thể nói someTile.addCanMatch (mới CircleMatchBehavior()). Điều này có vẻ ngớ ngẩn, như tôi sẽ có một loạt các lớp học chỉ nói rằng bạn có thể phù hợp với một hình dạng cụ thể.

Tóm lại, những gì tôi đang cố gắng thực hiện là có nhiều loại đối tượng có thể tương tác với bất kỳ số loại nào khác nhau. Câu hỏi đặt ra là, tôi nên sử dụng cái gì cho Loại. Có sử dụng GetType ở đây không? Enums? Hoặc là có một chiến lược tốt hơn ai đó sẽ giới thiệu? Tôi đang cố gắng hết sức có thể, những viên gạch này không nên có bất kỳ phụ thuộc mã hóa nào trên các loại gạch khác, và phải có khả năng thay đổi những người mà chúng có thể tương tác khi đang bay. Giả sử tôi tạo một lớp con Tile mới, ngũ giác ... tốt, Pentagons có thể phù hợp với Squares, Circles và Pentagons. Dễ dàng với việc thực hiện của tôi, nhưng một cái gì đó nói với tôi đây là một thực hành OOP bẩn.

Tôi cảm thấy mình phải sử dụng các loại/Enums vì tôi không cố gắng nói thisTile.addCanMatch (Tile someOtherObject). Đó là quá cụ thể, tôi muốn thisTile để có thể phù hợp với tất cả các gạch là trường hợp của một lớp học cụ thể.

Answer 1

Nếu tất cả các hình dạng của một loại tương tự sẽ luôn chia sẻ hành vi, thì có nghĩa là không lưu trữ hành vi đó ở cấp 'cho mỗi trường hợp'.Thay vào đó, bạn có thể có một 'CanMatchManager', lưu trữ một từ điển danh sách, được lập chỉ mục theo kiểu hình dạng. Sau đó, khi một vòng tròn cố gắng so sánh một trận đấu, nó sẽ yêu cầu các loại mà nó có thể khớp với MatchManager. Ngoài ra, MatchManager có thể lấy hai hình dạng, và xác định xem những trận đấu đó. Đây là Mediator Pattern

Answer 2

Tôi biết câu hỏi đã được trả lời và chấp nhận, nhưng tôi đã làm điều gì đó như thế này một lần và tôi nghĩ tôi chỉ đăng mã ở đây.

public class TypeMatchManager 
    { 
     private Dictionary<Type, List<Type>> savedMatches = new Dictionary<Type, List<Type>>(); 

     public TypeMatchManager() { } 

     public void AddMatch(Type firstType, Type secondType) 
     { 
      this.addToList(firstType, secondType); 
      this.addToList(secondType, firstType); 
     } 

     public void DeleteMatch(Type firstType, Type secondType) 
     { 
      this.deleteFromList(firstType, secondType); 
      this.deleteFromList(secondType, firstType); 
     } 

     public bool CanMatch(Type firstType, Type secondType) 
     { 
      List<Type> firstTypeList = this.findListForType(firstType); 
      List<Type> secondTypeList = this.findListForType(secondType); 
      return (firstTypeList.Contains(secondType) || secondTypeList.Contains(firstType)); 
     } 

     private void addToList(Type firstType, Type secondType) 
     { 
      var matchingTypes = this.findListForType(firstType); 
      if (!matchingTypes.Contains(secondType)) 
      { 
       matchingTypes.Add(secondType); 
      } 
     } 

     private void deleteFromList(Type firstType, Type secondType) 
     { 
      var matchingTypes = this.findListForType(firstType); 
      if (matchingTypes.Contains(secondType)) 
      { 
       matchingTypes.Remove(secondType); 
      } 
     } 

     private List<Type> findListForType(Type type) 
     { 
      foreach (var keyValuePair in savedMatches) 
      { 
       if (keyValuePair.Key == type) 
       { 
        return keyValuePair.Value; 
       } 
      } 
      savedMatches.Add(type, new List<Type>()); 
      return findListForType(type); 
     } 
    } 

Lớp học được thiết kế sao cho thông số bạn cung cấp không quan trọng; nó kiểm tra type1.list có type2 và type2.list có kiểu.

Một ví dụ đơn giản:

 typeManager.AddMatch(a, b); 
     Console.WriteLine(typeManager.CanMatch(a, b)); // True 
     typeManager.DeleteMatch(b, a); 
     Console.WriteLine(typeManager.CanMatch(a, b)); // False 
     Console.WriteLine(typeManager.CanMatch(a, c)); // False 
     typeManager.AddMatch(a, c); 
     Console.WriteLine(typeManager.CanMatch(a, c)); // True 
     Console.WriteLine(typeManager.CanMatch(a, d)); // False 
     typeManager.AddMatch(b, d); 
     Console.WriteLine(typeManager.CanMatch(a, d)); // False 
     Console.WriteLine(typeManager.CanMatch(d, b)); // True 
     typeManager.DeleteMatch(d, b); 
     Console.WriteLine(typeManager.CanMatch(d, b)); // False 
     Console.WriteLine(typeManager.CanMatch(b, d)); // False