Design principles are the fundamental guidelines that shape the visual and interactive aspects of a design. They are the building blocks that help designers create aesthetically pleasing, functional, and user-friendly experiences. By understanding and applying these principles, you can enhance the overall impact and effectiveness of your designs.
Core Design Principles
While there are numerous design principles, these are some of the most fundamental ones:
Visual Design Principles
- Emphasis: Creating a focal point to draw attention to the most important element.
- Balance: Distributing visual weight evenly to create a sense of stability.
- Contrast: Using differences in elements (color, size, shape) to create visual interest.
- Repetition: Consistently using elements to create rhythm and unity.
- Proportion: Creating harmonious relationships between elements based on size and scale.
- Movement: Guiding the viewer's eye through the design using lines, shapes, or color.
- White Space: Using empty space to enhance readability and focus.
Interaction Design Principles
- Hierarchy: Organizing information based on importance to guide user focus.
- Consistency: Maintaining a consistent visual and interactive style throughout the design.
- Affordance: Designing elements that clearly communicate their function.
- Feedback: Providing clear visual or auditory cues to user actions.
- Efficiency: Optimizing user interactions to minimize effort.
- Usability: Creating designs that are easy to learn and use.
1. Single Responsibility Principle (SRP)
Definition: A class should have only one reason to change, meaning it should have only one job or responsibility.
C# Example:
// Violates SRP: Handles both user data and report generation
public class UserService
{
public void AddUser(User user)
{
// Logic to add user
}
public void GenerateReport()
{
// Logic to generate a report
}
}
// Adheres to SRP
public class UserService
{
public void AddUser(User user)
{
// Logic to add user
}
}
public class ReportService
{
public void GenerateReport()
{
// Logic to generate a report
}
}
2. Open/Closed Principle (OCP)
Definition: Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification.
// Violates OCP: Modifying existing code to add new functionality
public class DiscountService
{
public double ApplyDiscount(double price, string discountType)
{
if (discountType == "seasonal")
{
return price * 0.9;
}
else if (discountType == "clearance")
{
return price * 0.8;
}
return price;
}
}
// Adheres to OCP: Adding new functionality without modifying existing code
public interface IDiscountStrategy
{
double ApplyDiscount(double price);
}
public class SeasonalDiscount : IDiscountStrategy
{
public double ApplyDiscount(double price)
{
return price * 0.9;
}
}
public class ClearanceDiscount : IDiscountStrategy
{
public double ApplyDiscount(double price)
{
return price * 0.8;
}
}
public class DiscountService
{
public double ApplyDiscount(double price, IDiscountStrategy discountStrategy)
{
return discountStrategy.ApplyDiscount(price);
}
}
3. Liskov Substitution Principle (LSP)
Definition: Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.
// Violates LSP: Subclass changes expected behavior of superclass
public class Rectangle
{
public virtual double Width { get; set; }
public virtual double Height { get; set; }
public double Area()
{
return Width * Height;
}
}
public class Square : Rectangle
{
public override double Width
{
set
{
base.Width = value;
base.Height = value;
}
}
public override double Height
{
set
{
base.Width = value;
base.Height = value;
}
}
}
// Adheres to LSP: Separate classes for different shapes
public interface IShape
{
double Area();
}
public class Rectangle : IShape
{
public double Width { get; set; }
public double Height { get; set; }
public double Area()
{
return Width * Height;
}
}
public class Square : IShape
{
public double SideLength { get; set; }
public double Area()
{
return SideLength * SideLength;
}
}
4. Interface Segregation Principle (ISP)
Definition: A client should not be forced to depend on methods it does not use. Split interfaces that are too large into smaller and more specific ones so that clients will only have to know about the methods that are of interest to them.
// Violates ISP: One large interface with unnecessary methods for some implementations
public interface IWorker
{
void Work();
void Eat();
}
public class Robot : IWorker
{
public void Work()
{
// Work logic
}
public void Eat()
{
throw new NotImplementedException();
}
}
// Adheres to ISP: Smaller, specific interfaces
public interface IWorkable
{
void Work();
}
public interface IFeedable
{
void Eat();
}
public class HumanWorker : IWorkable, IFeedable
{
public void Work()
{
// Work logic
}
public void Eat()
{
// Eat logic
}
}
public class Robot : IWorkable
{
public void Work()
{
// Work logic
}
}
5. Dependency Inversion Principle (DIP)
Definition: High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions.
// Violates DIP: High-level module depends on low-level module
public class LightBulb
{
public void TurnOn()
{
// Turn on logic
}
public void TurnOff()
{
// Turn off logic
}
}
public class Switch
{
private LightBulb _lightBulb = new LightBulb();
public void Operate()
{
_lightBulb.TurnOn();
}
}
// Adheres to DIP: Both high-level and low-level modules depend on abstractions
public interface IDevice
{
void TurnOn();
void TurnOff();
}
public class LightBulb : IDevice
{
public void TurnOn()
{
// Turn on logic
}
public void TurnOff()
{
// Turn off logic
}
}
public class Switch
{
private IDevice _device;
public Switch(IDevice device)
{
_device = device;
}
public void Operate()
{
_device.TurnOn();
}
}
Conclusion
By adhering to these design principles, you can create software that is more modular, easier to maintain, and adaptable to change. The principles of SRP, OCP, LSP, ISP, and DIP form the backbone of good software design and are crucial for developing robust applications in C#. Understanding and applying these principles will significantly improve the quality and longevity of your code.
No comments:
Post a Comment